Steema at Xamarin Evolve 2014

Steema Software has confirmed its presence as an exhibitor at Xamarin Evolve 2014. In this article I’ll explain what Steema Software will be presenting at the conference.

Xamarin  is planning Evolve 2014 as “The world’s largest cross-platform mobile development”. It will be held in Atlanta from Monday 6th October until Friday 10th.

From the Steema team, Josep Lluís Jorge (aka Pep) and Narcís Calvet (yours truly) will attend Evolve 2014. Pep is the man behind the TeeChart for Xamarin.iOS version, while I’m the responsible for the TeeChart for Xamarin.Android version. We expect to arrive at the Atlanta Hyatt Regency, where Xamarin Evolve 2014 is held, on Sunday afternoon so we will be around from then until the end of the conference. On Monday and Tuesday we will probably attend some training sessions. On Tuesday we will also be setting up the Steema Software booth at the exhibitor area. So, from Wednesday until Friday you will be able to find us at the mentioned booth and, if work permits, at some of the conference sessions. We will check out and fly back home on Saturday afternoon so as such, we’ll have been able to spend the entire Evolve 2014 time in Atlanta.

And what will Steema Software present? We will be glad to show and talk with you about any of Steema’s charting products (.NET, VCL/FMX, Java, PHP, HTML5, etc.), especially the Xamarin charting components and also showing a preview of TeeChart for Xamarin.Forms. Hot of the press, just ready for Evolve 2104!

An important part of the Steema team is now working hard to get everything ready for the weekend for us to travel to Atlanta and be able to show you as much as possible. Pep and I are looking forward to see all of you at Evolve and get the most out of it. Please don’t hesitate to drop by the Steema booth or reach us anywhere else during our stay there, we will be happy to speak with you. If you want to arrange a meeting, or for us to prepare something you’d be interested in  or anything else, please drop me an email. We will be glad to help you.

See you at Evolve 2014!

Real-time charting with TeeChart for Xamarin.Android

To complete the zooming and panning functionality description in the multi-touch article, I should also speak about one last case which concerns real-time performance. Actually, this is not a zoom/pan style but the lack of it.  It’s the the TChart.Zoom.Style property value not covered on that article, ZoomStyles.None.

So, what does ZoomStyles.None consists of exactly?  It disables zooming and scrolling and its main priority is refreshing the chart at the highest rate possible for real-time purposes. This is achieved via multi-threading and forcing the chart to paint on the UI thread. For this to work the RunOnUiThread delegate need to be implemented in your real-time charting applications.

Before getting too abstract, let’s brake things into pieces. This article is based on the RealTimeCharting demo project shipped with TeeChart for Xamarin.Android evaluation and registered versions.  We will start setting up the chart with the minimum elements required to represent our data trying to add as little work for the CPU as possible and therefore get a more responsible application. As you can see in the code snippet below, this involves disabling: 3D, legend, gradient, walls, automatic axes range calculation, etc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//Add the chart
tChart1 = new Steema.TeeChart.TChart(this);
tChart1.Aspect.View3D = false;
tChart1.Zoom.Style = Steema.TeeChart.ZoomStyles.None;
tChart1.Legend.Visible = false;
tChart1.Panel.Gradient.Visible = false;
tChart1.Walls.Back.Gradient.Visible = false;
tChart1.Walls.Back.Visible = false;
tChart1.Axes.Left.Grid.Visible = false;
tChart1.Axes.Bottom.Grid.Visible = false;
tChart1.Axes.Left.Automatic = false;
tChart1.Axes.Bottom.Automatic = false;
tChart1.Axes.Left.SetMinMax(MinValue, MaxValue);
tChart1.Axes.Bottom.SetMinMax(0, NumPoints);
tChart1.ClickSeries += new Steema.TeeChart.TChart.SeriesEventHandler(tChart1_ClickSeries);
 
//Left axis disabled for performance purposes.
tChart1.Axes.Left.Visible = false;
//Add the chart
tChart1 = new Steema.TeeChart.TChart(this);
tChart1.Aspect.View3D = false;
tChart1.Zoom.Style = Steema.TeeChart.ZoomStyles.None;
tChart1.Legend.Visible = false;
tChart1.Panel.Gradient.Visible = false;
tChart1.Walls.Back.Gradient.Visible = false;
tChart1.Walls.Back.Visible = false;
tChart1.Axes.Left.Grid.Visible = false;
tChart1.Axes.Bottom.Grid.Visible = false;
tChart1.Axes.Left.Automatic = false;
tChart1.Axes.Bottom.Automatic = false;
tChart1.Axes.Left.SetMinMax(MinValue, MaxValue);
tChart1.Axes.Bottom.SetMinMax(0, NumPoints);
tChart1.ClickSeries += new Steema.TeeChart.TChart.SeriesEventHandler(tChart1_ClickSeries);

//Left axis disabled for performance purposes.
tChart1.Axes.Left.Visible = false;

Besides setting the Zoom.Style to ZoomStyles.None, disabling some objects’ visibility and automatic axes range calculation, vertical axis is completely disabled to avoid it having to calculate labels or anything else that would require some precious computing time. Next thing to consider is the kind of chart style (we call it series in TeeChart) we will use for that kind of chart. This example uses a FastLine series, a specific line, reduced to the minimum expression for performance purposes.

1
2
3
var fastLine1 = new Steema.TeeChart.Styles.FastLine(tChart1.Chart);
fastLine1.FillSampleValues(NumPoints);
fastLine1.DrawAllPoints = false;
var fastLine1 = new Steema.TeeChart.Styles.FastLine(tChart1.Chart);
fastLine1.FillSampleValues(NumPoints);
fastLine1.DrawAllPoints = false;

It’s also worth mentioning the use of the DrawAllPoints property in FastLine series. This property controls how many points in a FastLine series will be displayed. When True (the default), all points are displayed. When set to False, it will only display points that have a different “X” position in screen pixels. So, when the series has several points that share the same X pixel position, but with different Y position, it will only display the first point (or use another chosen method via DrawAllPointsStyle property). When set to True (the default), only points that have a different X or a different Y pixel position are displayed. In some cases, setting DrawAllPoints can dramatically speed up displaying a FastLine series with lots lots of points. But, as not all points are displayed, the final output might not be as accurate.

After having explained that, I should only add that, in this project initialisation, a timer is being created to add data to the chart at a fixed continuous rate simulating a real-time data capturing environment.

1
2
3
4
timer1 = new System.Timers.Timer();
timer1.Elapsed += new System.Timers.ElapsedEventHandler(timer1_Elapsed);
timer1.Interval = 100;
timer1.Start();
timer1 = new System.Timers.Timer();
timer1.Elapsed += new System.Timers.ElapsedEventHandler(timer1_Elapsed);
timer1.Interval = 100;
timer1.Start();

The event that the timer triggers just implements RunOnUiThread delegate, which calls a method (AnimateSeries) that updates the series in the chart.

1
2
3
4
5
6
7
void timer1_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
  RunOnUiThread(delegate
  {
    AnimateSeries(tChart1);
  });
}
void timer1_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
  RunOnUiThread(delegate
  {
	AnimateSeries(tChart1);
  });
}

After the chart has been set up for work, the AnimateSeries method is where almost everything happens:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void AnimateSeries(Steema.TeeChart.TChart chart)
{
  var rnd = new Random();
  double newX, newY;
 
  tChart1.AutoRepaint = false;
 
  foreach (Steema.TeeChart.Styles.Series s in chart.Series)
  {
    // show only 50 points - delete the rest
    while (s.Count > NumPoints) s.Delete(0);
    if (s.Count > NumPoints) s.Delete(0);
    newX = s.XValues.Last + 1;
    newY = rnd.Next(MaxValue);
    if ((Math.Abs(newY) > MaxValue) || (Math.Abs(newY) < MinValue)) newY = 0.0;
    s.Add(newX, newY);
  }
 
  tChart1.Axes.Bottom.SetMinMax(tChart1.Axes.Bottom.Minimum + 1, tChart1.Axes.Bottom.Maximum + 1);
  
  tChart1.AutoRepaint = true;
  tChart1.Chart.Invalidate();
}
void AnimateSeries(Steema.TeeChart.TChart chart)
{
  var rnd = new Random();
  double newX, newY;

  tChart1.AutoRepaint = false;

  foreach (Steema.TeeChart.Styles.Series s in chart.Series)
  {
	// show only 50 points - delete the rest
	while (s.Count > NumPoints) s.Delete(0);
	if (s.Count > NumPoints) s.Delete(0);
	newX = s.XValues.Last + 1;
	newY = rnd.Next(MaxValue);
	if ((Math.Abs(newY) > MaxValue) || (Math.Abs(newY) < MinValue)) newY = 0.0;
	s.Add(newX, newY);
  }

  tChart1.Axes.Bottom.SetMinMax(tChart1.Axes.Bottom.Minimum + 1, tChart1.Axes.Bottom.Maximum + 1);
  
  tChart1.AutoRepaint = true;
  tChart1.Chart.Invalidate();
}

Besides generating some random data for the example chart, the most important thing here is the AutoRepaint property, which toggles chart repainting when new data is being added to the chart. To avoid the chart being repainted after every new point being added to it, we will disable it and will only enable it back, followed by a Chart.Invalidate() call, after all data has been added/removed from the series to force the chart being refreshed at this stage. In the meantime, if there are more points in the chart than those being specified by NumPoints constant, first points in the sequential range will be removed and new data will be added to the series in the same fashion. Finally, horizontal axis scale will be updated accordingly.

So we are done with it. In this article we have covered which are the basic TeeChart aspects you should consider modifying to get the most speed out of it. You probably know this is very important when handling large data volumes.

As mentioned at the beginning of the article, the complete example project is included with both TeeChart for Xamarin.Android evaluation and registered versions. However, for clarity and completeness of purpose, here’s the complete code listing:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
using System;
 
using Android.App;
using Android.OS;
using Android.Views;
using Android.Widget;
 
namespace RealTimeCharting
{
  [Activity(Label = "RealTimeCharting", MainLauncher = true, Icon = "@drawable/icon")]
  public class Activity1 : Activity
  {
    Steema.TeeChart.TChart tChart1;
    const int NumPoints = 50;
    const int MinValue = 0;
    const int MaxValue = 1000;
    System.Timers.Timer timer1;
 
    protected override void OnCreate(Bundle bundle)
    {
      base.OnCreate(bundle);
 
      // Set our view from the "main" layout resource
      SetContentView(Resource.Layout.Main);
 
      // Get our button from the layout resource,
      // and attach an event to it
      Button button = FindViewById<button>(Resource.Id.MyButton);
 
      button.Click += delegate 
      {
        timer1.Enabled = !timer1.Enabled;
        button.Text = (timer1.Enabled) ? Resources.GetString(Resource.String.Stop) : Resources.GetString(Resource.String.Start);
      };
 
      //Add the chart
      tChart1 = new Steema.TeeChart.TChart(this);
      tChart1.Aspect.View3D = false;
      tChart1.Zoom.Style = Steema.TeeChart.ZoomStyles.None;
      tChart1.Legend.Visible = false;
      tChart1.Panel.Gradient.Visible = false;
      tChart1.Walls.Back.Gradient.Visible = false;
      tChart1.Walls.Back.Visible = false;
      tChart1.Axes.Left.Grid.Visible = false;
      tChart1.Axes.Bottom.Grid.Visible = false;
      tChart1.Axes.Left.Automatic = false;
      tChart1.Axes.Bottom.Automatic = false;
      tChart1.Axes.Left.SetMinMax(MinValue, MaxValue);      
      tChart1.Axes.Bottom.SetMinMax(0, NumPoints);
      tChart1.ClickSeries += new Steema.TeeChart.TChart.SeriesEventHandler(tChart1_ClickSeries);
      
      //Left axis disabled for performance purposes.
      tChart1.Axes.Left.Visible = false;
 
      var fastLine1 = new Steema.TeeChart.Styles.FastLine(tChart1.Chart);
      fastLine1.FillSampleValues(NumPoints);
      fastLine1.DrawAllPoints = false;
 
      LinearLayout layout = FindViewById(Resource.Id.linearLayout1);
      layout.AddView(tChart1, new ViewGroup.LayoutParams(ViewGroup.LayoutParams.FillParent, 400));
 
      timer1 = new System.Timers.Timer();
      timer1.Elapsed += new System.Timers.ElapsedEventHandler(timer1_Elapsed);
      timer1.Interval = 100;
      timer1.Start();
    }
 
    void tChart1_ClickSeries(object sender, Steema.TeeChart.Styles.Series s, int valueIndex, MotionEvent e)
    {
      Toast
          .MakeText(this, "point " + valueIndex, ToastLength.Short)
          .Show();
    }    
 
    void timer1_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
    {
      RunOnUiThread(delegate
      {
        AnimateSeries(tChart1);
      });
    }
 
    void AnimateSeries(Steema.TeeChart.TChart chart)
    {
      var rnd = new Random();
      double newX, newY;
 
      tChart1.AutoRepaint = false;
 
      foreach (Steema.TeeChart.Styles.Series s in chart.Series)
      {
        // show only 50 points - delete the rest
        while (s.Count > NumPoints) s.Delete(0);
        if (s.Count > NumPoints) s.Delete(0);
        newX = s.XValues.Last + 1;
        newY = rnd.Next(MaxValue);
        if ((Math.Abs(newY) > MaxValue) || (Math.Abs(newY) < MinValue)) newY = 0.0;
        s.Add(newX, newY);
      }
 
      tChart1.Axes.Bottom.SetMinMax(tChart1.Axes.Bottom.Minimum + 1, tChart1.Axes.Bottom.Maximum + 1);
      
      tChart1.AutoRepaint = true;
      tChart1.Chart.Invalidate();
    }
  }
 
}</button>
using System;

using Android.App;
using Android.OS;
using Android.Views;
using Android.Widget;

namespace RealTimeCharting
{
  [Activity(Label = "RealTimeCharting", MainLauncher = true, Icon = "@drawable/icon")]
  public class Activity1 : Activity
  {
    Steema.TeeChart.TChart tChart1;
    const int NumPoints = 50;
    const int MinValue = 0;
    const int MaxValue = 1000;
    System.Timers.Timer timer1;

    protected override void OnCreate(Bundle bundle)
    {
      base.OnCreate(bundle);

      // Set our view from the "main" layout resource
      SetContentView(Resource.Layout.Main);

      // Get our button from the layout resource,
      // and attach an event to it
      Button button = FindViewById<button>(Resource.Id.MyButton);

      button.Click += delegate 
      {
        timer1.Enabled = !timer1.Enabled;
        button.Text = (timer1.Enabled) ? Resources.GetString(Resource.String.Stop) : Resources.GetString(Resource.String.Start);
      };

      //Add the chart
      tChart1 = new Steema.TeeChart.TChart(this);
      tChart1.Aspect.View3D = false;
      tChart1.Zoom.Style = Steema.TeeChart.ZoomStyles.None;
      tChart1.Legend.Visible = false;
      tChart1.Panel.Gradient.Visible = false;
      tChart1.Walls.Back.Gradient.Visible = false;
      tChart1.Walls.Back.Visible = false;
      tChart1.Axes.Left.Grid.Visible = false;
      tChart1.Axes.Bottom.Grid.Visible = false;
      tChart1.Axes.Left.Automatic = false;
      tChart1.Axes.Bottom.Automatic = false;
      tChart1.Axes.Left.SetMinMax(MinValue, MaxValue);      
      tChart1.Axes.Bottom.SetMinMax(0, NumPoints);
      tChart1.ClickSeries += new Steema.TeeChart.TChart.SeriesEventHandler(tChart1_ClickSeries);
      
      //Left axis disabled for performance purposes.
      tChart1.Axes.Left.Visible = false;

      var fastLine1 = new Steema.TeeChart.Styles.FastLine(tChart1.Chart);
      fastLine1.FillSampleValues(NumPoints);
      fastLine1.DrawAllPoints = false;

      LinearLayout layout = FindViewById(Resource.Id.linearLayout1);
      layout.AddView(tChart1, new ViewGroup.LayoutParams(ViewGroup.LayoutParams.FillParent, 400));

      timer1 = new System.Timers.Timer();
      timer1.Elapsed += new System.Timers.ElapsedEventHandler(timer1_Elapsed);
      timer1.Interval = 100;
      timer1.Start();
    }

    void tChart1_ClickSeries(object sender, Steema.TeeChart.Styles.Series s, int valueIndex, MotionEvent e)
    {
      Toast
          .MakeText(this, "point " + valueIndex, ToastLength.Short)
          .Show();
    }    

    void timer1_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
    {
      RunOnUiThread(delegate
      {
        AnimateSeries(tChart1);
      });
    }

    void AnimateSeries(Steema.TeeChart.TChart chart)
    {
      var rnd = new Random();
      double newX, newY;

      tChart1.AutoRepaint = false;

      foreach (Steema.TeeChart.Styles.Series s in chart.Series)
      {
        // show only 50 points - delete the rest
        while (s.Count > NumPoints) s.Delete(0);
        if (s.Count > NumPoints) s.Delete(0);
        newX = s.XValues.Last + 1;
        newY = rnd.Next(MaxValue);
        if ((Math.Abs(newY) > MaxValue) || (Math.Abs(newY) < MinValue)) newY = 0.0;
        s.Add(newX, newY);
      }

      tChart1.Axes.Bottom.SetMinMax(tChart1.Axes.Bottom.Minimum + 1, tChart1.Axes.Bottom.Maximum + 1);
      
      tChart1.AutoRepaint = true;
      tChart1.Chart.Invalidate();
    }
  }

}</button>

 

Using TeeChart Java with Android Studio

Minimal example using TeeChart Java in Google’s Android Studio.

Android Studio home page:

https://developer.android.com/sdk/installing/studio.html

Download:

Download the example (9MB)

If you want to recreate this project, the steps are as follows:

1) TeeChart Java for Android

The above example download includes an evaluation version of TeeChart.Android.jar library. (The evaluation version draws a watermark)

If you wish to download the full version or the full evaluation with examples and tutorials, please follow this link:

http://steema.com/download/java

2) Create a new project in Android Studio (blank activity)

3) Copy TeeChart library to the app\libs folder

In your example project folders, copy the TeeChart.Android.jar file (from the above download zip)

….\app\libs\TeeChart.Android.jar

After some seconds, Android Studio will automatically recognize the new copied file and will appear under the libs tree node.

If it doesn’t, right click the libs node and click on “Synchronize libs” option.

4) At the main activity java, type this code:

The main java source file is at (for example):

C:\Android Studio\app\src\main\java\com\david\demo\MyActivity.java

import com.steema.teechart.TChart;
import com.steema.teechart.drawing.Color;
import com.steema.teechart.styles.*;
import com.steema.teechart.styles.Series;

...

protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);

  setContentView(layout.activity_my);

  // Find the Layout:
  ViewGroup v;
  v = (ViewGroup) findViewById( id.mylayout );

  // Create a Chart and add it to Layout:
  TChart chart = new TChart( this );
  v.addView( chart );

  // Create a new series of data:
  Series series1 = new Pie( chart.getChart() ); // Bar,Area,Line etc

  // Add some sample data:
  
  series1.add( 123, "Apples", Color.green );
  series1.add( 456, "Oranges", Color.red );
  series1.add( 321, "Kiwis", Color.yellow );

  // Cosmetic options:
  chart.getAxes().getBottom().setIncrement( 1 );
  chart.getLegend().getFont().setSize(36); 
  series1.getMarks().getFont().setSize(36); 
  chart.getHeader().getFont().setSize(44); 
  chart.getPanel().getGradient().setVisible(true); 
} 

 

5) Run or debug

Clicking the ide Run or Debug buttons (or menu options) will execute the application.

A Pie chart appears with 3 slices at your Android device (phone or tablet), or at the emulator:

 

TeeChart Java for Android

 

 

 

 

Create a new MFC project with a Chart in Visual Studio 2010 and up

I wrote a quite detailed guide about how I created an MFC project with TeeChart v2014.0.0.1.
Here the step-by-step instructions:

 

– Create a new MFC project:

2014-07-09_1416

2014-07-09_1417

– Note I used “Dialog based” application type to make a simple project:

2014-07-09_1418

– Here it is the blank dialog we get:

2014-07-09_1419

– Drag a “TeeChart Pro ActiveX control v*”:

2014-07-09_1420

-Then we’ll have to create a variable to access the chart at runtime:

2014-07-09_1420_001

– Set a name to it (ie mChart1):

2014-07-09_1423

This action has created tchart1.h and tchart1.cpp in our solutuion.
However, if we build this project now, we get a few errors we need to fix.
The first three errors:

error C2365: ‘pmwNormal’ : redefinition; previous definition was ‘enumerator’ .\mfcaxtest\mfcaxtest\tchart1.h 1406 1 MFCAXTest
error C2365: ‘pmwInverted’ : redefinition; previous definition was ‘enumerator’ .\mfcaxtest\mfcaxtest\tchart1.h 1407 1 MFCAXTest
error C2365: ‘pmwNone’ : redefinition; previous definition was ‘enumerator’ .\mfcaxtest\mfcaxtest\tchart1.h 1409 1 MFCAXTest

We can fix them changing some defines at tchart1.h, where it says this:

1
2
3
4
5
6
enum
{
pmwNormal = 0,
pmwInverted = 1,
pmwNone = 2
}EMouseWheelStyle;
enum
{
pmwNormal = 0,
pmwInverted = 1,
pmwNone = 2
}EMouseWheelStyle;

 

Change it for this:

1
2
3
4
5
6
enum
{
pmwsNormal = 0,
pmwsInverted = 1,
pmwsNone = 2
}EMouseWheelStyle;
enum
{
pmwsNormal = 0,
pmwsInverted = 1,
pmwsNone = 2
}EMouseWheelStyle;

 

This error:

error C2365: ‘tsNone’ : redefinition; previous definition was ‘enumerator’ .\mfcaxtest\mfcaxtest\tchart1.h 1525 1 MFCAXTest

We can fix it changing some other defines at tchart1.h, where it says this:

1
2
3
4
5
6
enum
{
tsNone = 0,
tsStacked = 1,
tsStacked100 = 2
}ETowerStacked;
enum
{
tsNone = 0,
tsStacked = 1,
tsStacked100 = 2
}ETowerStacked;

 

Change it for this:

1
2
3
4
5
6
enum
{
twsNone = 0,
twsStacked = 1,
twsStacked100 = 2
}ETowerStacked;
enum
{
twsNone = 0,
twsStacked = 1,
twsStacked100 = 2
}ETowerStacked;

 

And this one:

error C2664: ‘CTchart1::CTchart1(const CTchart1 &)’ : cannot convert parameter 1 from ‘int’ to ‘const CTchart1 &’ .\mfcaxtest\mfcaxtest\mfcaxtestdlg.cpp 54 1 MFCAXTest

We can fix it removing the 0 argument at MFCAXTestDlg.cpp, where it says this:

1
2
3
CMFCAXTestDlg::CMFCAXTestDlg(CWnd* pParent /*=NULL*/)
: CDialogEx(CMFCAXTestDlg::IDD, pParent)
, mChart1(0)
CMFCAXTestDlg::CMFCAXTestDlg(CWnd* pParent /*=NULL*/)
: CDialogEx(CMFCAXTestDlg::IDD, pParent)
, mChart1(0)

 

Change it for this:

1
2
3
CMFCAXTestDlg::CMFCAXTestDlg(CWnd* pParent /*=NULL*/)
: CDialogEx(CMFCAXTestDlg::IDD, pParent)
, mChart1()
CMFCAXTestDlg::CMFCAXTestDlg(CWnd* pParent /*=NULL*/)
: CDialogEx(CMFCAXTestDlg::IDD, pParent)
, mChart1()

 

– Now, just to make things a bit more clean (so this is optional), add this to the “protected” section at MFCAXTestDlg.h:

1
void initChart();
void initChart();

 

Add this at the end of MFCAXTestDlg.cpp:

1
2
3
4
void CMFCAXTestDlg::initChart()
{
 
}
void CMFCAXTestDlg::initChart()
{

}

 

And call initChart at the end of OnInitDialog, still at MFXAXTestDlg.cpp:

1
2
3
4
5
6
7
8
9
10
BOOL CMFCAXTestDlg::OnInitDialog()
{
//...
 
// TODO: Add extra initialization here
 
initChart();
 
return TRUE; // return TRUE unless you set the focus to a control
}
BOOL CMFCAXTestDlg::OnInitDialog()
{
//...

// TODO: Add extra initialization here

initChart();

return TRUE; // return TRUE unless you set the focus to a control
}

 

At this point the project builds fine, and we have the mChart1 variable but this variable doesn’t give us access to the chart properties and methods.

 

– Open the “Class Wizzard”:

2014-07-09_1624

– Select the “MFC Class From ActiveX Control…” option in the Add submenu:

2014-07-09_1621

– Select “TeeChart Pro ActiveX control v*” in the combobox and move “ITChart” to the “Generated classes” box:

2014-07-09_1622

This creates CTChart.h and CTChart.cpp. Now, at MFCAXTestDlg.h, change the include:

1
#include "tchart1.h"
#include "tchart1.h"

 

For this:

1
#include "CTChart.h"
#include "CTChart.h"

And also change mChart1 declaration:

1
CTchart1 mChart1;
CTchart1 mChart1;

 

For this:

1
CTChart mChart1;
CTChart mChart1;

 

– Now you should be able to see the chart methods and properties for mChart1. Ie, at MFCAXTestDlg.cpp:

1
2
3
4
void CMFCAXTestDlg::initChart()
{
mChart1.AboutBox();
}
void CMFCAXTestDlg::initChart()
{
mChart1.AboutBox();
}

 

But you only see the properties and methods at the chart level. To get access to the other classes, we still have to create and include the other required headers.

 

– Open again the “Class Wizard”. And this time select the “MFC Class From TypeLib…” option in the Add submenu:

2014-07-09_1432

– Move all the interfaces to the “Generated classes” (>> button):

2014-07-09_1432_001

Now a lot of headers have been added to the solution. But they include this line that will give us more problems:

1
#import "C:\\Program Files (x86)\\Steema Software\\TeeChart Pro v2014 ActiveX Control\\TeeChart2014.ocx" no_namespace
#import "C:\\Program Files (x86)\\Steema Software\\TeeChart Pro v2014 ActiveX Control\\TeeChart2014.ocx" no_namespace

 

So we have to use the “Quick Replace” function in Visual Studio (Ctrl+H) to replace the line above for this on the entire solution to remove it:

1
//#import "C:\\Program Files (x86)\\Steema Software\\TeeChart Pro v2014 ActiveX Control\\TeeChart2014.ocx" no_namespace
//#import "C:\\Program Files (x86)\\Steema Software\\TeeChart Pro v2014 ActiveX Control\\TeeChart2014.ocx" no_namespace

 

Now we use write the code we want for the chart initialization on MFCAXTestDlg.cpp. Ie:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//...
#include "CTitles.h"
#include "CAspect.h"
#include "CLegend.h"
#include "CSeries.h"
#include "CColorGridSeries.h"
#include "CPen0.h"</code>
 
//...
 
void CMFCAXTestDlg::initChart()
{
    CTitles header = mChart1.get_Header();
    header.put_Caption(mChart1.get_Version());
 
    CAspect a = mChart1.get_Aspect();
    a.put_View3D(false);
 
    CLegend l = mChart1.get_Legend();
    l.put_Visible(false);
 
    mChart1.AddSeries(30);
    CSeries s = mChart1.Series(0);
    s.FillSampleValues(100);
    CColorGridSeries cgs = s.get_asColorGrid();
    CPen0 cgsPen = cgs.get_Pen();
    cgsPen.put_Visible(false);
}
//...
#include "CTitles.h"
#include "CAspect.h"
#include "CLegend.h"
#include "CSeries.h"
#include "CColorGridSeries.h"
#include "CPen0.h"</code>

//...

void CMFCAXTestDlg::initChart()
{
	CTitles header = mChart1.get_Header();
	header.put_Caption(mChart1.get_Version());

	CAspect a = mChart1.get_Aspect();
	a.put_View3D(false);

	CLegend l = mChart1.get_Legend();
	l.put_Visible(false);

	mChart1.AddSeries(30);
	CSeries s = mChart1.Series(0);
	s.FillSampleValues(100);
	CColorGridSeries cgs = s.get_asColorGrid();
	CPen0 cgsPen = cgs.get_Pen();
	cgsPen.put_Visible(false);
}

Multi Touch with TeeChart for Xamarin.Android

Now that you know how to get started with TeeChart for Xamarin.Android, let’s get into a more interesting topic, multi-touch with TeeChart and Xamarin.Android.

From its inception, TeeChart for Xamarin.Android supports multi-touch gestures. However, since the release of build 4.14.6.25 in June 2014, the multi-touch offering has been extended with the implementation of the entire ZoomStyles.Classic functionality. In this article we will explain the different options presented to the programmer/user and what they can offer.

There are several ways to perform zooming and panning with TeeChart for Xamarin.Android. The door to the different possibilities is the TChart.Zoom.Style property. So we will elaborate on each specific value of Steema.TeeChart.ZoomStyles enum.

ZoomStyles.Classic

This is the most complete and versatile option available and the one which came the latest, as mentioned above. Choosing it the chart will zoom and scroll in a very similar way to the desktop version. However, instead of pressing a mouse button and drawing the zoom rectangle while dragging the mouse over the chart, it will respond to pinch gestures zooming the chart according to the virtual rectangle comprised between two finger pointers. This means dragging the fingers apart will zoom in the chart while closing them together will zoom the chart out. I must add this is automatically activated when two pointers are pressing the chart. If only one single pointer is pressing it panning will be activated instead. Actually, this is not 100% true, those options will be automatically activated only if the Allow property is also active (e.g.: TChart.Zoom.Allow and TChart.Panning.Allow). A little code snippet will help understanding this better:

1
2
3
tChart1.Zoom.Allow = true;
tChart1.Zoom.Direction = Steema.TeeChart.ZoomDirections.Both;
tChart1.Panning.Allow = Steema.TeeChart.ScrollModes.Horizontal;
tChart1.Zoom.Allow = true;
tChart1.Zoom.Direction = Steema.TeeChart.ZoomDirections.Both;
tChart1.Panning.Allow = Steema.TeeChart.ScrollModes.Horizontal;

The chart in the code above will be allowed to zoom in horizontal and vertical directions while will only allow scrolling in horizontal directions. Zoom has Allow and Direction self-explanatory properties, Panning does everything with one single property. To disable panning one should use Steema.TeeChart.ScrollModes.None. BTW, should ask to the TeeChart “fathers” about the reason behind this difference! writing this article has been useful to rethink this, deprecate Zoom.Allow property and add a new ZoomDirections.None enum value for Zoom.Direction property. Having that in mind, versions published after mid-July 2014 should use this code instead:

1
2
tChart1.Zoom.Direction = Steema.TeeChart.ZoomDirections.Both;
tChart1.Panning.Allow = Steema.TeeChart.ScrollModes.Horizontal;
tChart1.Zoom.Direction = Steema.TeeChart.ZoomDirections.Both;
tChart1.Panning.Allow = Steema.TeeChart.ScrollModes.Horizontal;

Finally, double tapping on the screen will undo any scroll or zooming action.

So, in resume, this options includes exactly the same functionality as the desktop version and gives complete control to the user about which scaling or translation will the chart perform.

ZoomStyles.FullChart

The two following options are simpler and are based on image scaling and translation instead of drawing directly to the chart canvas as the previous option does. So, FullChart will also perform to pinch and drag gestures but scrolling or zooming the chart as an image in its entirety.

ZoomStyles.InChart

This adds some sophistication to the FullChart option. Internally it separates the chart in 4 areas: background, chart rectangle, left axis and bottom axis. This is because when zooming or scrolling, performing pinch or drag gestures, on the chart rectangle (the area comprised between the axes where the series are being painted), this area will be transformed as an image, as ZoomStyles.FullChart but, this time, axes will also be transformed as individual images to keep in synch with the chart rectangle. The chart background won’t be affected by those changes. So, all in all, this is some kind of hybrid version between ZoomStyles.Classic and ZoomStyles.FullChart.

ZoomStyles.None

This option won’t allow zooming nor scrolling the chart. This is only intended for real-time charting applications where performance is optimized and therefore, zooming and panning not allowed. It’s not only that some chart settings are modified to optimise performance but the way the chart is internally painted also changes. Threads running on the UI should be used to add data to the chart and refresh it for real-time smoothness. An example of this can be seen in the RealTimeCharting example included with both evaluation and registered versions.

Summary

In a nutshell, in this article we can see that TeeChart for Xamarin.Android supports a varied multi-touch offering to fit a wide range of requirements, giving many options to the programmer/user. It’s also worth mentioning all of this doesn’t forget touch events on the chart and series!

Getting started with TeeChart for Xamarin.Android

It’s been some time now since TeeChart for Xamarin.Android was released, in August 2012, following the path Xamarin started drawing about one year before. While Xamarin has made huge progress during this time, the corresponding TeeChart version has also evolved and improved during this time.

If you are reading this, you probably got started with Xamarin.Android. We will elude the Xamarin products details and focus on using TeeChart on them.

Xamarin Studio

After creating a new blank Android application, the easiest and fastest way is using the TeeChart version in the Xamarin Component Store. Here’s a Xamarin guide on how to use it. Let’s apply that to TeeChart now. In an Android application, choose Project > Edit Components > Open Component Store (or Get More Components). This will load the component store for you:

ComponentStore

In the image above, you can see the TeeChart Charting Library as the 5th overall option. You can also find it in the Libraries category or find it with the given search option. Anyway, selecting the TeeChart Charting Library turns up to this screen:

TeeChartComponentStore

Besides the product info, getting started link, license, etc. there are two green buttons here. They will let you either evaluate the component or purchase it. A couple of things to comment here. First, the evaluation version is fully functional and the only limitation you’ll experience with it is a watermark over the charts. Second, evaluation and registered versions are also available at www.steema.com. Later on I will explain how to use the components outside the Component Store but now let’s continue with that. To do so I’ll choose the Try button option.

After agreeing to the licensing terms, this will add the TeeChart for Xamarin.Android trial version to your project, as an item in the Components folder and also as a TeeChart.Android.dll assembly reference in the References folder. The “references” part is all we will have to take care of to use TeeChart.Android.dll from outside the Component Store. The TeeChart entry in the Components list will also open the corresponding tab in Xamarin Studio’s main window:

TeeChartProjectComponents

The mentioned TeeChart tab has 3 sub tabs: Getting Sarted, Samples and Assemblies. Actually, those names are self-explanatory. The first one contains some basic information and code snippets to get one quickly started developing Android applications with TeeChart. The second one includes sample projects for iOS and Android. The third tab contains information about the assemblies included with the component and their version.

Prior to start developing our own application, we will try with the Android example pressing the corresponding button in the Samples tab. Doing so will add the MonoAndroidDemo project to our solution. The example project comes with a reference to the TeeChart.Android.dll we have chosen (trial or registered) and is ready to run on your emulator or device of choice.

Now, back to the Getting Started tab, there’s a little Android code snippet which we can copy and paste at the OnCreate method on our Activity:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
protected override void OnCreate (Bundle bundle)
{
    base.OnCreate (bundle);
 
    Steema.TeeChart.TChart tChart1 = new Steema.TeeChart.TChart(this);        
    Steema.TeeChart.Styles.Bar bar1 = new Steema.TeeChart.Styles.Bar();       
    tChart1.Series.Add(bar1);        
    bar1.Add(3, "Pears", Color.Red);       
    bar1.Add(4, "Apples", Color.Blue);       
    bar1.Add(2, "Oranges", Color.Green);        
    Steema.TeeChart.Themes.BlackIsBackTheme theme = new Steema.TeeChart.Themes.BlackIsBackTheme(tChart1.Chart);       
    theme.Apply();        
    SetContentView(tChart1);
}
protected override void OnCreate (Bundle bundle)
{
	base.OnCreate (bundle);

	Steema.TeeChart.TChart tChart1 = new Steema.TeeChart.TChart(this);        
	Steema.TeeChart.Styles.Bar bar1 = new Steema.TeeChart.Styles.Bar();       
	tChart1.Series.Add(bar1);        
	bar1.Add(3, "Pears", Color.Red);       
	bar1.Add(4, "Apples", Color.Blue);       
	bar1.Add(2, "Oranges", Color.Green);        
	Steema.TeeChart.Themes.BlackIsBackTheme theme = new Steema.TeeChart.Themes.BlackIsBackTheme(tChart1.Chart);       
	theme.Apply();        
	SetContentView(tChart1);
}

so that we have our first TeeChart for Xamarin.Android application ready to go.

GettingStartedSample

Let me explain what those lines of code exactly mean. We start creating a TChart object, the basic object of the component set, which is the chart container. A Bar series comes after, it’s being created and added to the chart component. After that, some bars are added to the bar series: Y values, text labels and bar colors. Afterwards a chart theme is being created and applied to the chart to change the overall aspect. Finally, the chart component is being added to fill the parent view entirely. Getting a chart into your Android application is as simple as that.

If are no not using the Xamarin Component Store because you are using a TeeChart.Android.dll downloaded directly from Steema it wouldn’t much different. You should just manually browse for TeeChart.Android.dll in your hard drive at the References folder in your project: References > right mouse button -> Edit References > .Net Assembly. Here you’ll need to browse for the assembly in your disk and add it to the project.

ManualReference

Changing the trial version assembly from the Component Store to the registered version I have on my computer, I now get the same example without the evaluation watermark.

GettingStartedSampleRegistered

Visual Studio

There are no substantial differences on the basics of creating Android projects in Xamarin Studio and Visual Basic. As Xamarin explains in the Components Walkthrough article, Component Store is being used the same way in Visual Studio. A Components is added to each project. From there you can access the store with your Xamarin license credentials. Also, manually adding assembly references to your project works very much the same way.

Summary

Now that you know how to use TeeChart in your C# Android applications, you are all good to start representing your data graphically in Android with C#. TeeChart for Xamarin.Android installers for Windows and Mac OSX, supplied by Steema Software, include some more demos, help files and a number of tutorials completing a wide range of TeeCharting aspects. Also, at the Steema Support forums for registered customers, you’ll find a huge number of questions with examples covering almost aspects of TeeChart. Non-registered users can post their technical inquiries at StackOverflow tagged with “TeeChart” and the platform/language.

If you are a native Java Android developer, Steema Software also has a native component for you, TeeChart Java for Android. Those targeting Android from Embarcadero IDEs, can use the TeeChart VCL/FMX version.