1

SOLVED

The problem wasn’t the graph exceeding its container, as the labels and other graph elements were displaying correctly within the entire graph area. The graph area is internally controlled by the SciChart object and the issue started appearing after I upgraded to the new version, so I knew it was something to do with the changes wihtin SciChart (which were outside of my control).

It turned out the cause of this was setting the WPF dependency property UsetLayoutRounding to False (the default is True). In the previous version of SciChart labels near the graph edges were removed, whereas from version 3.0 they are left to be drawn. The same problem would have occurred in the previous version too if it had allowed labels near the edges to be drawn. It was quite a tricky issue to track down, as just by coincidence it was “hidden” in the precious version and started occurring in the new one even though there was technically no change to the way labels are rendered.

So I might have a solution for this. The machine in question was restarted in safe-mode and then the application was started and worked fine. So it had to be some kind of driver issue right? So there was an intel-driver for an onboard graphics card that was the cause of the whole issue. This driver was uninstalled and again it was working fine. Downloaded and installed a new updated driver and now everything works fine.

So anyone else having this issue, try running the application in safe-mode. If the zoom works fine in safe-mode, chances are you may have the same buggy driver installed. Check for updates for that graphics driver.

Hope this helps

Best regards,
Lisbeth

Mark thank you for your input again. I ended up using a similar code. here is my solution (not including the serialization which is straightforward .

 [Serializable]
 public class Annotation
 {
     public Annotation(){} 
      
     public Annotation(IAnnotation sciChartAnnotation)
     {
         FromChartAnnotation(sciChartAnnotation);
     }
      
     public AnnotationsType AnnotationType { get; set; }
 
     public double? X1 { get; set; }
     public double? X2 { get; set; }
 
     public double? Y1 { get; set; }
     public double? Y2 { get; set; }
 
     public String Text { get; set; }
     public String YAxisId { get; set; }
 
     public Colour Background { get; set; }
     public Colour Foreground { get; set; }
     public Colour BorderBrush { get; set; }
     public Colour Stroke { get; set; }
 
     public SThickness Thickness { get; set; }
 
     public double StrokeThickness { get; set; }
 
     public bool ShowLabel { get; set; }
     public LabelPlacement LabelPlacement { get; set; }
     public HorizontalAlignment HorizontalAlignment { get; set; }
     public VerticalAlignment VerticalAlignment { get; set; }
     public IAnnotation GetChartAnnotation()
     {
         IAnnotation obj = null;
 
         Type chartAnnotationType = Type.GetType("Abt.Controls.SciChart." + AnnotationType.ToString() + ", Abt.Controls.SciChart.Wpf" );
         if (chartAnnotationType != null)
         {
             obj = (IAnnotation) Activator.CreateInstance(chartAnnotationType, null, null);
             obj.X1 = X1;
             obj.X2 = X2;
             obj.Y1 = Y1;
             obj.Y2 = Y2;
 
             if (obj as TextAnnotation != null)
                 (obj as TextAnnotation).Text = Text;
 
             if (obj as LineAnnotation != null)
             {
                 (obj as LineAnnotation).Background = new SolidColorBrush(Background); 
                 (obj as LineAnnotation).BorderThickness = Thickness;
                 (obj as LineAnnotation).Foreground = new SolidColorBrush(Foreground);
             }
             if (obj as LineArrowAnnotation != null)
             {
                 (obj as LineArrowAnnotation).Background = new SolidColorBrush(Background);
                 (obj as LineArrowAnnotation).BorderThickness = Thickness;
                 (obj as LineArrowAnnotation).Foreground = new SolidColorBrush(Foreground);
             }
 
             if (obj as BoxAnnotation != null)
             {
                 (obj as BoxAnnotation).Background = new SolidColorBrush(Background);
                 (obj as BoxAnnotation).BorderThickness = Thickness;
                 (obj as BoxAnnotation).BorderBrush = new SolidColorBrush(BorderBrush);
             }
 
             if (obj as HorizontalLineAnnotation != null)
             {
                 (obj as HorizontalLineAnnotation).Background = new SolidColorBrush(Background);
                 (obj as HorizontalLineAnnotation).BorderThickness = Thickness;
                 (obj as HorizontalLineAnnotation).BorderBrush = new SolidColorBrush(BorderBrush);
                 (obj as HorizontalLineAnnotation).Stroke = new SolidColorBrush(Stroke);
                 (obj as HorizontalLineAnnotation).StrokeThickness = StrokeThickness;
                 (obj as HorizontalLineAnnotation).ShowLabel = ShowLabel;
                 (obj as HorizontalLineAnnotation).LabelPlacement = LabelPlacement;
                 (obj as HorizontalLineAnnotation).HorizontalAlignment = HorizontalAlignment;
             }
 
             if (obj as VerticalLineAnnotation != null)
             {
                 (obj as VerticalLineAnnotation).Background = new SolidColorBrush(Background);
                 (obj as VerticalLineAnnotation).BorderThickness = Thickness;
                 (obj as VerticalLineAnnotation).BorderBrush = new SolidColorBrush(BorderBrush);
                 (obj as VerticalLineAnnotation).Stroke = new SolidColorBrush(Stroke);
                 (obj as VerticalLineAnnotation).StrokeThickness = StrokeThickness;
                 (obj as VerticalLineAnnotation).ShowLabel = ShowLabel;
                 (obj as VerticalLineAnnotation).LabelPlacement = LabelPlacement;
                 (obj as VerticalLineAnnotation).VerticalAlignment = VerticalAlignment;
             }
         }
 
         return obj;
     }
 
     public void FromChartAnnotation(IAnnotation sciChartAnnotation)
     {
         String typeStr = sciChartAnnotation.GetType().ToString();
         typeStr = typeStr.Substring(typeStr.LastIndexOf('.') + 1);
 
         AnnotationsType type;
         if (Enum.TryParse(typeStr, true, out type))
         {
             AnnotationType = type;
             X1 = (double) sciChartAnnotation.X1;
             X2 = (double) sciChartAnnotation.X2;
             Y1 = (double) sciChartAnnotation.Y1;
             Y2 = (double) sciChartAnnotation.Y2;
 
             YAxisId = sciChartAnnotation.YAxisId;
         }
         else
             throw new NotImplementedException();
 
         if (sciChartAnnotation as TextAnnotation != null)
             Text = (sciChartAnnotation as TextAnnotation).Text;
 
         if (sciChartAnnotation as LineAnnotation != null)
         {
             if ((sciChartAnnotation as LineAnnotation).Background as SolidColorBrush != null)
                 Background = ((sciChartAnnotation as LineAnnotation).Background as SolidColorBrush).Color;
 
             Thickness = (sciChartAnnotation as LineAnnotation).BorderThickness;
             if ((sciChartAnnotation as LineAnnotation).Foreground as SolidColorBrush != null)
                 Foreground = ((sciChartAnnotation as LineAnnotation).Foreground as SolidColorBrush).Color;
         }
         if (sciChartAnnotation as LineArrowAnnotation != null)
         {
             if ((sciChartAnnotation as LineArrowAnnotation).Background as SolidColorBrush != null)
                 Background = ((sciChartAnnotation as LineArrowAnnotation).Background as SolidColorBrush).Color;
             Thickness = (sciChartAnnotation as LineArrowAnnotation).BorderThickness;
             if ((sciChartAnnotation as LineArrowAnnotation).Foreground as SolidColorBrush != null)
                 Foreground = ((sciChartAnnotation as LineArrowAnnotation).Foreground as SolidColorBrush).Color;
         }
 
         if (sciChartAnnotation as BoxAnnotation != null)
         {
             if ((sciChartAnnotation as BoxAnnotation).Background as SolidColorBrush != null)
                 Background = ((sciChartAnnotation as BoxAnnotation).Background as SolidColorBrush).Color;
             Thickness = (sciChartAnnotation as BoxAnnotation).BorderThickness;
             if ((sciChartAnnotation as BoxAnnotation).Foreground as SolidColorBrush != null)
                 Foreground = ((sciChartAnnotation as BoxAnnotation).Foreground as SolidColorBrush).Color;
         }
 
         if (sciChartAnnotation as HorizontalLineAnnotation != null)
         {
             if ((sciChartAnnotation as HorizontalLineAnnotation).Background as SolidColorBrush != null)
                 Background = ((sciChartAnnotation as HorizontalLineAnnotation).Background as SolidColorBrush).Color;
             if ((sciChartAnnotation as HorizontalLineAnnotation).BorderBrush as SolidColorBrush != null)
                 BorderBrush = ((sciChartAnnotation as HorizontalLineAnnotation).BorderBrush as SolidColorBrush).Color;
             if ((sciChartAnnotation as HorizontalLineAnnotation).Stroke as SolidColorBrush != null)
                 Stroke = ((sciChartAnnotation as HorizontalLineAnnotation).Stroke as SolidColorBrush).Color;
             Thickness = (sciChartAnnotation as HorizontalLineAnnotation).BorderThickness;
             StrokeThickness = (sciChartAnnotation as HorizontalLineAnnotation).StrokeThickness;
             ShowLabel = (sciChartAnnotation as HorizontalLineAnnotation).ShowLabel;
             LabelPlacement = (sciChartAnnotation as HorizontalLineAnnotation).LabelPlacement;
             HorizontalAlignment = (sciChartAnnotation as HorizontalLineAnnotation).HorizontalAlignment;
         }
 
         if (sciChartAnnotation as VerticalLineAnnotation != null)
         {
             if ((sciChartAnnotation as VerticalLineAnnotation).Background as SolidColorBrush != null)
                 Background = ((sciChartAnnotation as VerticalLineAnnotation).Background as SolidColorBrush).Color;
             if ((sciChartAnnotation as VerticalLineAnnotation).BorderBrush as SolidColorBrush != null)
                 BorderBrush = ((sciChartAnnotation as VerticalLineAnnotation).BorderBrush as SolidColorBrush).Color;
             if ((sciChartAnnotation as VerticalLineAnnotation).Stroke as SolidColorBrush != null)
                 Stroke = ((sciChartAnnotation as VerticalLineAnnotation).Stroke as SolidColorBrush).Color;
 
             Thickness = (sciChartAnnotation as VerticalLineAnnotation).BorderThickness;
             StrokeThickness = (sciChartAnnotation as VerticalLineAnnotation).StrokeThickness;
             ShowLabel = (sciChartAnnotation as VerticalLineAnnotation).ShowLabel;
             LabelPlacement = (sciChartAnnotation as VerticalLineAnnotation).LabelPlacement;
             VerticalAlignment = (sciChartAnnotation as VerticalLineAnnotation).VerticalAlignment;
         }
     }
 }
 
 [Serializable]
 public enum AnnotationsType
 {
     LineAnnotation,
     LineArrowAnnotation,
     TextAnnotation,
     BoxAnnotation,
     HorizontalLineAnnotation,
     VerticalLineAnnotation,
     AxisMarkerAnnotation
 }
 
 
 [Serializable]
 public struct SThickness
 {
     public double Top;
     public double Bottom;
     public double Left;
     public double Right;
 
     public SThickness(double top, double bottom, double left, double right)
     {
 
         Top = top;
         Bottom = bottom;
         Left = left;
         Right = right;
     }
 
     public SThickness(Thickness thickness)
         : this(thickness.Top, thickness.Bottom, thickness.Left, thickness.Right)
     {
     }
 
     public static implicit operator SThickness(Thickness thickness)
     {
         return new SThickness(thickness);
     }
 
     public static implicit operator Thickness(SThickness thickness)
     {
         return new Thickness(thickness.Left, thickness.Top, thickness.Right, thickness.Bottom);
     }
 }
 
 [Serializable]
 public struct Colour
 {
     public byte A;
     public byte R;
     public byte G;
     public byte B;
 
     public Colour(byte a, byte r, byte g, byte b)
     {
         A = a;
         R = r;
         G = g;
         B = b;
     }
 
     public Colour(Color color)
         : this(color.A, color.R, color.G, color.B)
     {
     }
 
     public static implicit operator Colour(Color color)
     {
         return new Colour(color);
     }
 
     public static implicit operator Color(Colour colour)
     {
         return Color.FromArgb(colour.A, colour.R, colour.G, colour.B);
     }
 }

Hi there,

Thanks for your enquiry! There is ChartModifierBase.ReceiveHandledEvents property, you should use it to prevent mouse events interfering. Also there is an option to set ExecuteOn property to change event which triggered execution. Or you can control modifiers via IsEnabled property, turning it on to particular one and off to others.

Hope this helps!

Best regards,
Yuriy

I am considering applying server-side licensing for my javerScript application.

In the document below, there is a phrase “Our server-side licensing component is written in C++.”
(https://support.scichart.com/index.php?/Knowledgebase/Article/View/17256/42/)

However, there is only asp.net sample code on the provided github.
(https://github.com/ABTSoftware/SciChart.JS.Examples/tree/master/Sandbox/demo-dotnet-server-licensing)

I wonder if there is a sample code implemented in C++ for server-side licensing.

Can you provide c++ sample code?
Also, are there any examples to run on Ubuntu?

Newsflash. This actually works

1: Declare the theme resource in your UserControl.Resources

Allowable theme resource dictionary names are BlackSteel.xaml, Electric.xaml, Oscilloscope.xaml, BrightSpark.xaml, Chrome.xaml, ExpressionDark.xaml, ExpressionLight.xaml

 <UserControl.Resources>

    <ResourceDictionary>
        <ResourceDictionary.MergedDictionaries>
            <ResourceDictionary Source="pack://application:,,,/Abt.Controls.SciChart.Wpf;component/Themes/BlackSteel.xaml"/>
        </ResourceDictionary.MergedDictionaries>
    </ResourceDictionary>
</UserControl.Resources

2: Use the brushes directly as static resource

 <TextBlock FontSize="20" Text="Hello Theming World!" Foreground="{StaticResource TickTextBrush}"/>

Allowable resource names are listed in the KB Article on ThemeColorProviders.

Best regards,
Andrew

Update: SciChart v4

We have a working solution with SciChart v4 below. What we have done is implemented showing the context menu on SciChartSurface.PreviewMouseUp event.

We have also overridden ZoomPanModifier to ensure that e.Handled is only ever true when panning (e.g. if Start / End Point are not the same).

Here’s the code:

MainWindow.xaml

<Window x:Class="WpfApplication85.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:s="http://schemas.abtsoftware.co.uk/scichart"
        xmlns:wpfApplication85="clr-namespace:WpfApplication85"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <s:SciChartSurface Name="sciChart" PreviewMouseUp="SciChart_OnPreviewMouseUp">
            <s:SciChartSurface.ContextMenu>
                <ContextMenu>
                    <MenuItem Header="Item1" />
                    <MenuItem Header="Item2" />
                </ContextMenu>
            </s:SciChartSurface.ContextMenu>

            <s:SciChartSurface.XAxis>
                <s:NumericAxis/>
            </s:SciChartSurface.XAxis>

            <s:SciChartSurface.YAxis>
                <s:NumericAxis/>
            </s:SciChartSurface.YAxis>

            <s:SciChartSurface.ChartModifier>
                <s:ModifierGroup>
                    <wpfApplication85:ZoomPanModifierEx ExecuteOn="MouseRightButton" ClipModeX="None"></wpfApplication85:ZoomPanModifierEx>                    
                    <s:CursorModifier ReceiveHandledEvents="True" />
                </s:ModifierGroup>
            </s:SciChartSurface.ChartModifier>
        </s:SciChartSurface>
    </Grid>
</Window>

MainWindow.xaml.cs

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private void SciChart_OnPreviewMouseUp(object sender, MouseButtonEventArgs e)
    {
        if (e.RightButton == MouseButtonState.Pressed)
        {
            ((SciChartSurface)sender).ContextMenu.IsOpen = true;
            e.Handled = true;
        }
    }
}  

ZoomPanModifierEx.cs

public class ZoomPanModifierEx : ZoomPanModifier
{
    private Point _startPoint;

    public override void OnModifierMouseDown(ModifierMouseArgs e)
    {
        base.OnModifierMouseDown(e);

        _startPoint = e.MousePoint;
    }

    public override void OnModifierMouseUp(ModifierMouseArgs e)
    {
        base.OnModifierMouseUp(e);

        if (_startPoint == e.MousePoint) e.Handled = false;
    }
}

Best regards,
Andrew

Hi Andrew,

Thanks for the quick response. Your solution works perfectly. In case it helps others, here’s the full code:

public class ExtendRightFastLineRenderableSeries : FastLineRenderableSeries
{
    private double yLast;

    protected override void InternalDraw(IRenderContext2D renderContext, IRenderPassData renderPassData)
    {
        var xEnd = renderContext.ViewportSize.Width;
        var xLast = 0d;

        if (base.GetIsValidForDrawing())
        {
            base.InternalDraw(renderContext, renderPassData);

            var points = renderPassData.PointSeries;

            yLast = renderPassData.YCoordinateCalculator.GetCoordinate(points.YValues.Last());
            xLast = renderPassData.XCoordinateCalculator.GetCoordinate(points.XValues.Last());                
        }

        using (var linePen = renderContext.CreatePen(this.SeriesColor, this.AntiAliasing, this.StrokeThickness))
        {
            using (var lineDrawingContext = renderContext.BeginLine(linePen, xLast, yLast))
            {
                lineDrawingContext.MoveTo(xEnd, yLast);
            }
        }
    }

    protected override bool GetIsValidForDrawing()
    {
        return true;
    }
}

Hacked, but working very nice without fixed delay:

async Task ZoomOutDelayed()
{
    if (RenderableSeries.Count() > 0)
    {
        SciChart.Charting.Visuals.ISciChartSurface parentSurface = null;
        //While parentSurface is null
        var task = Task.Run(() =>
        {
            while (parentSurface == null)
            {
                parentSurface = ((LineRenderableSeriesViewModel)RenderableSeries.ElementAt(0)).DataSeries.ParentSurface;
            }
        });
        //Wait until timeout
        if (await Task.WhenAny(task, Task.Delay(2000)) == task)
        {
            parentSurface.ViewportManager.AnimateZoomExtents(TimeSpan.FromMilliseconds(250));
        }
    }
}

I am considering applying server-side licensing for my javerScript application.

In the document below, there is a phrase “Our server-side licensing component is written in C++.”
(https://support.scichart.com/index.php?/Knowledgebase/Article/View/17256/42/)

However, there is only asp.net sample code on the provided github.
(https://github.com/ABTSoftware/SciChart.JS.Examples/tree/master/Sandbox/demo-dotnet-server-licensing)

I wonder if there is a sample code implemented in C++ for server-side licensing.

Can you provide c++ sample code?
Also, are there any examples to run on Ubuntu?

Got it, used CustomAnnotation with Content set to Checkbox. I ‘ll put it here for future reference:

    var checkAnnotation = new CustomAnnotation()
        {
            X1 =  2,
            Y1 = 3,
            X2 = X1,
            Y2 = Y1 + 0.05 ,
            AnnotationCanvas = AnnotationCanvas.AboveChart,
            IsSelected = false,
            IsEditable = false,
            Content = new CheckBox()
        };

     ((CheckBox)checkAnnotation.Content).Click += checkAnnotation_Click;

Hello, Minsub Kim.
Thank you for your interest in SciChart.

In the first case, formatting is not fully correct. And the second case works as expected.
Let me explain, in more details:
‘textFormatting’ property is used by NSNumberFormatter object under the hood, and NSNumberFormatter – accepts format patterns based on Unicode Technical Standard #35.
So ‘0’ symbol in number format string means, that digit will be always displayed (odd zero in case if actual digit is absent). If you want flexible trailing zeros use ‘#’ symbol instead of ‘0’. For example ‘0.0##’ format will convert 2.3345 number to 12.334, and 1.2 number will be displayed as is.

If you want to build more advanced formats – here is a link to Unicode Technical Standard #35 and NSNumberFormatter documentation.

Hope, this information will help.
Best Regards,
Andriy.