This technical document describes all changes made to TeeChart component library (FireMonkey and VCL versions) since the release of January 2015.
New Support IDEs
Full support for RAD Studio, Delphi and C++ Builder XE8.
Completely redesigned installers system. One installer for all IDEs. It downloads and installs required components on demand.
There’s also an off-line installer available, which doesn’t require network access and is shipped with all downloadable components.
2015 brings some aesthetic improvements for TeeChart VCL/FMX and .NET versions with the intention to make it easier for our users to create visually appealing charts.
Different aspects about new theme usage and possibilities in TeeChart VCL/FMX to accomplish that objective are described in this article
New built-in chart themes with corresponding new color palettes
Lookout theme example showing all the colors in the so called Lookout palette.
Associated to the Lookout and Andros themes respectively
Andros theme example showing all the colors in the associated Seawash palette.
This technical document describes all changes made to TeeChart component library (FireMonkey and VCL versions) since the release of September 2014.
PDF export improvements
Improvements to PDF export include support for gradients and multiple page exports.
Legend horizontal justify
Justifies the contents of the Legend, when horizontal to provide an equal space between Legend Symbols based on clearing the length of the longest Legend item text.
If non-justified, the space between the end of each element and the next is equal, leading to different spaces between Legend items if their texts are of a different length.
The AxisScrollerTool provides a Scroller Bar adjacent to the Chart Axis to which it is associated.
View a live demo of new TeeChart TImport class on TeeChart Pro VCL / FMX:
Current data formats accessible through TeeChart’s TDataImport:
New tabs at editor dialogs allow customizing the new Selected and Hover properties.
The default value of Chart1.BufferedDisplay property is (finally) True for Firemonkey Charts.
(Default value in VCL has always been True).
The importance of BufferedDisplay is bigger in mobile applications (using the GPU Canvas) than desktop projects. The internal bitmap buffer gives a big speed increase when repainting a chart many times (like when scrolling or zooming chart data). Another internal change (caching a Firemonkey TextLayout) also increases the speed of painting texts (axis labels, legend items, etc).
The current issue with mobile devices is that graphics GPU speed (and the CPU speed) is still much lower compared to normal desktop computers. Ten times slower for most devices. This means some animations or simply zooming a chart on a desktop that runs at 30 frames per second, will execute at just 3 frames per second on a mobile device, which is quite unusable.
XE7 Canvas has several improvements that, together with the above changes in TeeChart code, shows a typical increase (on for example Google Nexus devices), from 4 to 19 frames per second.
Incoming plans to speed-up TeeChart are testing the new “FMX Enhancements / LKSL” open-source libraries from “LaKraven Studios Ltd.” See this GitHub repository:
A new class for both VCL and FMX, to visually animate changes on multiple Bar series.
Check the Firemonkey examples demo under Animations->Bar Transitions (DemoAnimBars.pas unit).
Add several Bar series (with same number of points), and a Bar Transition animation:
And then this code when you want to start the animation:
procedure TBarTransitions.Button1Click(Sender: TObject);
var tmp : TSeriesTransitionAnimation;
tmp:=(ChartAnimation1.Animations as TSeriesTransitionAnimation);
// Example, change the MultiBar property of Bar:
if Series1.MultiBar=mbSelfStack then
A new animation class (for VCL and FMX) to display one or more Line series in “progressive” mode (from first to last point in the series, with smooth interpolation in between points).
The DemoAnimLines.pas unit under Firemonkey examples demo shows it in action.
Add one or more Line series to a chart and a “Line Animation” animation, and then this code:
procedure TProgressiveLines.Button1Click(Sender: TObject);
New OnStop event, called when that particular item stops.
Bubble Cloud Series
New Series style to display data as an spirall of bubbles around a starting center one.
Derives from TCustom3DPalette series, inheriting all properties related to creating a color palette based on series data values.
Several properties control how bubbles are aligned, rotated and distanced:
New visual component to display a map of a TTree control.
The map navigator displays a full whole Tree (that can be huge) and a selection rectangle to reflect the current part visualized in the Tree.
The rectangle can be scrolled to navigate in the target Tree.
When not zero, the pen color used to draw a border around series pointer shapes will be calculated based on the brush color (the color used to fill the pointer interior).
Negative values mean brighter colors, positive values means darker colors.
When zero (the default), the Pen.Color is used instead of the pointer interior Brush.Color.
Series1.Pointer.DarkPen := -100; // From -255 to 255
New Grid.DrawAlways boolean property (default False).
When True, axis grid lines will be painted even if the axis labels are hidden:
-sources:”path” Indicates the root folder containing TeeChart source code.
-log:”filename” Indicates the filename to save the full process log.
New Height and HeightUnits properties for Legend Symbol.
The vertical size of Symbols in Chart Legend can now be specified in pixels or as a percentage of available space (that depends on the size of the Legend Font).
Important change: The Legend Symbol Squared property is now TRUE by default.
It was FALSE before. The reason is cosmetic. Squared symbols look better in more situations and different series styles, than non-squared.
Chart1.Legend.Symbol.Squared := False
Series Transparency property is now used to display Legend Symbols, in order to improve matching the series format with the legend.
New Clicked method, returns the Series and the series ValueIndex’th point that is under the XY pixel parameters:
Returns “nil” if no point of any series contains XY.
One example of use is at MarksTip tool, this tool calls SeriesList Clicked method to obtain which series is under the mouse cursor.
Bar and HorizBar Series
Improved detection in mouse xy Clicked method for 3D Bar cubes and diamond styles.
The algorithm now includes the bar cube sides in 3D view (orthogonal and perspective).
New marks style “smsLabelOrValue”. This is now the default Style.
If Series point label text is empty, uses point value instead.
Series1.Marks.Style := smsLabelOrValue
New Automatic property (of type TAutomaticText)
Note: This property is not yet handled by all series styles. So far it is used by Map and World series.
The intention of “Automatic” is to perform several attempts to avoid series marks overlap other marks or other parts of the chart. It is True by default in all subproperties.
Note: The existing AutoPosition property is now deprecated and mapped to the Automatic.Move property.
Marks will be first repositioned to avoid overlapping. Its after auto positioning when Automatic.Hide takes place if the mark still can’t be appropiately displayed.
Automatic.Resize means the series will try to reduce the mark font size to fit the mark inside the available space, before deciding to hide the mark completely.
Automatic.Wrap means to split the mark text into several lines of text, to try to fit the mark.
Automatic.Rotate means to rotate 45 or 90 degrees the mark, as it can be sometimes more convenient to fit more marks.
New InflateMargins boolean property (default True).
When False, Line or Area series will not try to expand the axes to accommodate for the border size. This is more noticeable when the Series1.Pen.Width is bigger than 2.
New Frame property (of type TFramedBorder).
This property was only available before in Pie and Gauge series. Now it has been moved and adapted to the more generic “Circled” series, so it can be used for other series like Polar series.
“Frame” , when enabled, displays a cosmetic 3-ring gradient around the circle perimeter.
Series1.Frame.Visible := True
New Pointer Arrow style (psArrow enum type):
Series1.Pointer.Style := psArrow
New Picture property (of type TTeePicture) to display an image at pointer.
New public properties:
SizeUnits (suPixels or suAxis)
SizeFloat allows specifying pointer size with more precision (with decimals), while SizeUnits lets calculate pointer size using axes scales instead of screen pixels.
This means, when “suAxis”, zooming a chart will also display zoomed pointers.
This feature is primarily used internally by TMapSeries.
Improved display of less-than-360 degree Circular gauge Frame border.
Smooth painting of range color lines (with more precision and antialias).
New Hands collection property for Circular Gauge. More than one “Hand” can now be displayed. Each hand has its own formatting and Value.
The previous “Hand” property is still supported, but now refers to Hands item.
New Circular gauge Hand style: psArrow (draws an arrow head at Hand end position).
Series1.Hand.Style := psArrow
New Ranges collection property for Linear, Knob and Circular gauges, allows more than two colored segments inside the gauges. Existing “GreenLine” and “RedLine” properties are still supported, but they now refer to Range and Range.
Each Range now supports displaying normal or “spiralled” segments.
Each Range now includes a new Position property (% radius from gauge center), and StartValue and EndValue properties to define the Range boundaries.
New AxisRanges collection property, allows drawing Axes in range segments.
Each “range” segment has Format properties.
Automatic calculation of gauge axis Increment (the step between gauge axis labels), to avoid overlapping labels. Same as with normal charts, automatic Increment when its zero.
New TClockGauge series. An example of a Clock made with a circular gauge, using 3 Hands (Hours, Minutes and Seconds).
Circular Gauge axis labels are now displayed using the Axis DrawAxisLabel method instead of a simple Canvas Texout. This allows supporting all Axis.Texts formatting properties, like background, shadow, etc.
Gauge editor dialogs have been modified to support editing (and adding, deleting) multiple Ranges and Hands items at design-time and runtime.
CircularGauge Marks now supported.
Gauge Hand value can be displayed using the default Marks property, located below the gauge center.
Series1.Marks.Visible := True
Improved support for semi-transparent (alpha) PNG images, for both GDI and GDI+ canvases.
Transparent PNG pictures are now correctly blended with the background (note:
Chart1.BufferedDisplay property must be True).
This applies to both Canvas Draw and StretchDraw methods.
New CubeHull method returns the polygon that encloses a 3D cube. It is used by CustomBar series (to detect mouse clicks on 3D bars with the Clicked method), and Canvas ClipCube method to limit drawing outside the 3D “cube” delimited by axes.
New internal IsAvailable boolean class virtual function.
GDI+ canvas overrides this function, see Other Changes below.
GDI+ canvas now correctly displays flat shadows when any object’s Shadow.Smooth property is False.
Chart1.Legend.Shadow.Smooth := False
OpenGL canvas improved display of Pen Transparency. And better Zoom matching when switching from a non-opengl canvas.
World and Map series “Layers”.
“Layers” concept for Maps can be easily implemented by using additional series. Each Layer being a different Series, with its own properties, and painted one after the other over the same chart.
Also, more than one Map or World series can be used and combined in the same chart.
With this new release, Map Layers get more useful as there are new methods to handle GIS file formats like Google’s Earth KML with placemarks, and ShapeFile files containing polylines (roads, etc).
World Country names have been augmented with country ISO 2-letter codes (ie: Canada=CA)
Series Marks can now display country names, codes, or both.
China, France, Japan county maps are now included. One polygon is used for each county / province.
New TeeFlags.res resource, contains all country flags pictures as small gifs.
These flags can be used in World series to display them inside each country polygon, and also at chart grid when visualizating country data.
To enable showing flags, a new property is introduced:
Series1.Flags.Visible := True
New AddCities class method.
Passing a series to this method, it returns the series filled with XY points and texts of the biggest world cities. XY values are indicated as longitude / latitude in degrees.
TWorldSeries.AddCities( MySeries1 )
This is useful to for example display a TPointSeries showing pointers at cities locations.
The list of city names and positions is internally stored at a custom resource.
New Entities property (note: experimental)
The Entities property contains a tree structure of nodes, each node being a polygon group.
Every node in the Entities tree contains a Shapes field (array of TTeePolygon).
This can be used for example to modify properties like for example changing the Transparency of all Asian countries easily:
var Asia : TTeePolygons;
Asia := WorldSeries1.Entities.Asia;
for t := 0 to Length(Asia)-1 do
Asia[t].Transparency := 50 ;
New TTeePolygon Code (string) property. This is an alternative string to Text property, and can be used when displaying Series Marks inside the polygon.
New TTeePolygon Centroid function (returns TPoint). Centroid returns the XY point inside the polygon that is best equidistant to all polygon points. This is different than the middle XY position of the polygon bounding rectangle.
Centroid position is used when displaying text Marks inside the polygon.
New TTeePolygon Picture property (of type TBackImage). Allows filling the polygon interior using an image.
New TTeePolygonGroup class, allows creating logical groups of polygons (shapes) to change properties of all items with a single group property. Groups are used for example by World series to keep together continent countries or country states or provinces.
New Shapes.ByCode array property, returns shape that has a given Code:
var tmp : TTeePolyong;
tmp := Series1.Shapes.ByCode[‘CA’] ; // Returns shape that corresponds to “Canada”
New MapMarks property. Contains properties to customize displaying series text marks inside polygons:
MapSeries1.MapMarks.AutoSize := False
AutoSize (boolean default True), fits text inside polygon by changing font size.
Centroid (boolean default True), positions text at polygon centroid instead of center of polygon rectangle bounds.
TextStyle (mtLabel, mtCode, mtBoth) choose which polygon text to display.
Uppercase (boolean default False), when True, show mark text in uppercase.
New Pointer property (TSeriesPointer) and PointSize (Single).
These properties enable Map series to display items as simple “pointer” shapes instead of polygons. It is useful for example to display thousands of dots over a World map, being each dot an Airport or a City or whatever.
When Point size is zero (the default), size is automatically changed when zooming the map.
MapSeries1.Pointer.Style := psCircle
TTeeKMLSource.Load method allows parsing and loading Google Earth files to extract places (PlaceMark nodes), and routes (LineString nodes), to display them over maps.
The only disadvantadge compared to system hints is the shape cannot be displayed outside the chart bounds.
When SystemHints is False, the new Format property (of type TTeeShape) contains all the formatting properties (Brush, Pen, Font, etc) to display the hint.
MarksTip tool is now supported in Firemonkey, by setting the above SystemHints property to False by default.
As a good side effect, NearestTool in Firemonkey now supports displaying Hints using MarksTip tool.
New TSubChart tool Clone method.
Duplicates a subchart. Can be used at runtime and also at design-time with a new Clone button at SubChart tool editor dialog.
ChartTool1.Charts.Clone( ChartTool1.Charts );
Chart Gallery Panel
New small feature in gallery panel. When NumCols property is zero, columns will be automatically calculated based on row height, so you don’t need to specify the number of columns in advance if you don’t know it, or if you want to keep “squared” charts in the gallery (same width and height), no matter how big is the container panel width.
New SelectSeries(ASeries) method, to focus the gallery chart that contains a series of the same class as the ASeries parameter.
Chart Gallery size is now stored at Windows Registry to preserve and use it each time the gallery is displayed.
Chart Tools Gallery dialog also loads and stores its size at Registry.
New TagObject (of type TObject) property added at TCustomChartElement base class.
Allows assigning any object to almost any object inside TeeChart.
This is similar to Firemonkey TagObject and VCL Tag (integer) properties.
More colors added to AndroidPalette (Android Theme), from 9 to 14.
Chart Titles and Footers delayed creation (to increase speed when creating new charts)
ChartListBox control now correctly detects changes to Chart.Legend.CheckBoxes property to display a checkbox or a radioitem for each series in the list.
New Firemonkey TSeriesEditor.EditMarks method to modally display the Marks editor dialog.
ImagePoint series now reuses the new Pointer.Picture property instead of creating an additional internal one.
Series Pointer objects make now use of their Transform property to for example rotate or animate them.
New icons for Series styles, with a more “modern” design.
Protection against exceptions when using the GDI+ canvas from inside a dll.
If the GDIPLUS.dll is not initialized by the caller executable, TeeChart GDI+ canvas now will detect this problem and will use the old GDI canvas, instead of raising an exception.
See this blog page for more information.
This protection is also done at Chart Gallery panel control, used by many editor dialogs.
The new GDI+ Canvas IsAvailable boolean function returns False when GDI+ cannot be used in the current environment (ie: inside a dll when the exe caller has not initialized GDI+).
Some improvements in the old TAntiAliasCanvas (TeeAntialias.pas). Note: this canvas is deprecated, GDI+ canvas replaces it.
Picture file size is now displayed at Image editor dialog.
This technical document describes all changes made to TeeChart component library (FireMonkey and VCL versions) since the release of November 2013.
XE5 Update 2
C++ iOS linker requires packages to be located under IDE \Lib\iosDevice\Debug folder.
TeeChart Pro packages are copied to that folder when recompiling and installing them using the TeeRecompile or TeeInstall tools.
Original TeeChart Lite iOS packages are still copied to Lib\Backup_TeeChart folder, and restored from there when uninstalling TeeChart Pro (using the TeeInstall tool).
New property DrawQuality : TStretchDrawQuality (default value: sqHigh)
Available for both GDI+ and GDI (VCL) and Firemonkey
For GDI, low quality means to use GDI StretchDraw / Blt instead of TeeSmooth internal algorithm.
For GDI+, quality is managed using GDI+ InterpolationMode (HighQuality or NearestNeighbor)
In Firemonkey, Canvas.DrawBitmap is used (HighSpeed parameter).
Chart1.BackImage.DrawQuality := sqLow;
New property UseSeriesTransparency : Boolean (default True)
When False, series marks will be painted using their own transparency, without accumulating the marks series transparency, if any.
Series1.Marks.UseSeriesTransparency : = False;
New Series (FireMonkey)
VCL series TImagePoint and TDeltaPoint have been ported to FireMonkey.
New Series.Legend property of type TTextShape.
This new property includes a Picture property to display an image or icon for each series at the Chart Legend Symbol.
Thanks to this new property, the existing Series1.ShowInLegend is now equivalent to Series1.Legend.Visible, and Series1.LegendTitle is the same as Series1.Legend.Text.
TImagePoint and TDeltaPoint
Improved painting of legend symbols, these series now show the corresponding image for each point at the legend (for VCL and FireMonkey).
ColorGrid, Surface, TriSurface Series
Speed improvements, caching calculated values to avoid repeating and spending time at each repaint (like when doing zoom and scroll).
Adding or modifying series point values empties the cache so it will be recalculated at the next repaint.
Experimental for OpenGL canvas only: New “Reuse3D” protected property.
When True, 3D Surfaces will be displayed from data in the GPU memory instead of creating and moving it from the CPU. This means (in most cases) greater speed when redrawing a chart (like when zooming, scrolling or rotating).
TMySurface(Series1).Reuse3D := True;
Bar and HorizBar Series
Cylinders are now painted filling them with gradients, instead of drawing “sides”.
The output is of much better quality (and speed), although currently there is no rotation of gradients when the chart is rotated with 3D perspective.
The ConePercent property (from 0 to 100, default 0) is now published (it was public).
Null values (in grid cell data) are now supported. Contour levels will not use null data.
Series1.SetNull( 23 ); // ← point index 23 is now null
New Filled property (boolean, default False).
This property is equivalent to setting Brush.Style := bsSolid, but more convenient and easy to remember.
Series1.Filled := True;
Changed filling algorithm. Cells are now filled using exactly the same calculation as contour level lines.
Performance note: Although cell filling is performed with GDI+ disabled antialias (to avoid visual artifacts), the old GDI canvas is faster. GDI+ polygon filling is slower than GDI, and this is very noticeable when painting thousands or millions of cell segments.
For best speed use the OpenGL Canvas (with the TTeeOpenGL component or directly using TGLCanvas class).
Improved repaint speed
Contour levels calculation is cached between repaints (if no series data or colors have been changed).
Support for Transform animations at polygon level.
That is, each polygon in the Map series (or WorldMap series) can be independently translated, scaled and rotated.
Right now the Transform property is protected as its not yet completely defined.
TMyPolygon(Series1.Shapes).Transform.Translate.X := 50;
New RenderMode property. Default is “rmDefault”.
When setting to “rm2D” in 3D mode, polygons will be displayed using the same “Z” coordinate (the same Z as the parent series).
By default each polygon has its own Z position and, in 3D, it displays at a different “depth” position. Setting RenderMode to rm2D disables this.
New maps: UK and Germany counties.
Note: County label names not yet included.
As a result of the global modifications to TMapSeries, World maps are now faster, and specially fast if you’re using OpenGL Canvas both in 2D and 3D.
New property: KeepAspect (boolean, default True).
When displaying a map, the aspect ratio (width vs. height) is by default applied to axis scales to not distort the map appearance, also when resizing the chart. Note: Chart1.Zoom.KeepAspectRatio should be set to True to preserve width-to-height proportions when zooming maps.
Polar Contour Series
New series style to display contour lines from XYZ data using Polar (Angle and Radius) coordinates.
This series is derived from Polar series class (to draw circular background, axes, etc), and includes a Contour series internal field (to calculate the contouring lines, customize contour levels, etc).
“X” indexes are converted to angles (from 0 to 360 degree). For example if the 3D grid has NumXValues = 10, then every angle interval will be 36.
“Z” indexes determine the radius, and the “Y” values are used to calculate the level lines.
Data can be manually added using the Series1.AddXYZ or AddNullXZ methods.
Typical settings for geographical data are to set 90 degree at top (North), and drawing labels clockwise (270 = West, 90 = East).
New method to remove (destroy) all series that have been created using the Series Stats tool editor dialog:
New button at Series Stats dialog editor that allows removing (destroying) all series added using it.
New Title, SubTitle, Foot and SubFoot properties are now persisted at design-time and can be accessed also by code:
ChartTool1.Title.Caption := ‘Speed’ ;
This is equivalent to access: ChartTool1.Chart.Title.Caption
New experimental code to draw multiple fast-line series in parallel using more than one CPU (see below for complete info).
New (advanced) protected properties to indicate FastLine to avoid recalculating axis coordinates for X and/or Y values.
If you are displaying realtime FastLine updates and need top speed, and your “X” coordinates never change (Y values are the ones changed only), then you can set this boolean flag to save the time to recalculate X positions in axis space again and again:
TMyFast(Series1).ReuseXValues := True;
Polar, Radar and WindRose Series
New property ColorEachLine boolean property (default True).
When ColorEachPoint is True, ColorEachLine determines if lines connecting points will be also colored segment by segment.
The help file is currently obsolete and in *.hlp format, not generally supported in Windows Vista and later.
Available documentation and tutorials can be found at http://wiki.teechart.net
VCL: Default Monitor to show the Chart Editor is now set to Desktop monitor.
Speed improvement for all 3D grid series (ColorGrid, Surface, etc) by replacing a loop with a binary-search algorithm in GetSurfacePaletteColor method which is used to calculate the appropiate color of a given “Y” value using the Palette array.
Typical gains are about 30% faster for big series (for example a ColorGrid of 1000x1000 cells).
Anscestor class has been changed for TPoint3DSeries.
Instead of TCustom3DSeries, now its TCustom3DPaletteSeries.
This adds automatically all the palette properties to Point3D series, allowing each Point3D point to be colorized based on its Y value. (This is the same class that other series like Surface, ColorGrid, etc inherit from).
New PointerBehind boolean property (default is False).
This applies to all series derived from Line and Polar that have a Pointer property. When PointerBehind is True, pointers will be displayed behind the line (in 2D mode only).
Also the line draw style should be set to “dsAll” (to draw first all pointers and then a line using all points, instead of one-point, one-line “dsSegments”)
New AngleLabels property groups all (now deprecated) CircleLabelsXXX properties into a common place:
Series1.CircleLabelsFont.Size := 20 ;
Series1.AngleLabels.Font.Size := 20;
New DrawStyle property (default “dsSegments”)
Setting DrawStyle to dsAll will draw the Polar line connecting all points using a single Polyline instead of multiple “segment” lines.
This means its now possible to set Pen.Fill properties like Gradient (Radial direction) to colorize lines depending on each point distance to the polar center.
New SeriesList property (of type TCustomSeriesList) allows selecting one or more Series to export data, instead of exporting all Series in a Chart.
procedure TForm1.FormCreate(Sender: TObject);
var data : TSeriesDataText;
// Add only the Series you want to export:
New property DrawBehind (boolean, default False).
DrawBehind determines if the legend has to be painted below (behind) or on top of Chart.
This is useful when ResizeChart is False, to make the legend “float” over the chart.
Chart1.Legend.DrawBehind := True;
New ValueIndex property that can be used in OnCalculate event.
The ValueIndex is the loop iterator position, and it only makes sense to use it inside the OnCalculate event.
The default value for ValueIndex outside the event is “-1” (no index).
ValueIndex range goes from “0” to TeeFunction1 “NumPoints-1”
procedure TForm1.TeeFunction1Calculate(Sender: TCustomTeeFunction;
const x: Double; var y: Double);
New Position property (Start, Center, End), default = Center.
By default axis titles are positioned to the middle of the axis.
Chart1.Axes.Bottom.Title.Position := tpStart;
New TeeAnimation class to display Line series progressively.
The animated GIF picture below shows line series with progressive animation:
A LineAnimation can be created at runtime (Chart1.Animations.Add(TLineAnimation.Create)) or at design-time using the Chart Editor dialog, Animations subtab.
New protected property PlayByFrames (boolean, default False).
When True, the animation is performed without considering the time interval, that is, all animation frames are played as fast as possible.
This is useful for the new feature explained below in GIF export format (creating an animated GIF picture using a Chart Animation or a TeeAnimate).
New optional parameter in Play method: SynchronizeMain (boolean, default True).
When calling Animate.Play passing False, there will no thread synchronization with the main UI thread. This can be useful to play animations that should play “locked”, and not leave “time” to the user interface. This means animations will not refresh the Chart display, they will be “hidden” animations. The animated GIF feature uses this mode to create the animated picture without repainting the chart at each frame.
Animated GIF export (VCL only)
New optional Animation and Animate properties, when either assigned, creates an animated GIF file from the frames generated while playing the animation.
The Animation (or Animate) Speed (frames per second), Duration and Loop properties define how is the GIF created. Typical animated GIFs use 15 fps or less to avoid generating a huge *.gif file.
with TGIFExportFormat.Create do
Animate:=TeeAnimate1; // or Animation := Chart1.Animations
New OptimizeColors property (boolean, default False). When True, GIF colors are “optimized” (see VCL TGIFImage for more info).
OpenGL Canvas (TGLCanvas)
Implemented support for 2D clipping rectangle (Chart1.ClipPoints:=True).
Note: Clipping only works correctly with Chart1.View3DOptions.Zoom:=100 (no zoom).
Pen Transparency supported (when Pen.Color Alpha component is <> 0)
Fixed detection and request for multi-sample (anti-alias) OpenGL pixel formats.
Improved speed of Polyline method, used by FastLine series when DrawStyle = All.
All FastLine data points are sent to the GPU with a single OpenGL operation.
New ScreenSync property (ssSystem, ssYes, ssNo) to enable or disable monitor refresh VSync synchronization.
If you need more than (typically 60hz frames-per-second), disabling ScreenSync might provide more repaint frames per second.
or equivalent way if not using TeeOpenGL component:
(Chart1.Canvas as TGLCanvas).ScreenSync := ssNo;
Implemented support for Transform animations.
New PolygonConcave method. Non-convex simple polygons are first converted to triangles (tessellated) and then the triangles are painted.
Note: As tesellating is a costly operation, its better to pre-calculate the triangles and reuse them if the polygon coordinates have no changed.
New TGLCanvas Tessellate method. Returns an array of PointFloats with the triangles calculated to cover the polygon points passed as XY arrays.
Used currently only by Map and World series.
Calculation is done using the GLUT dll Tessellator object.
The resulting array can then be displayed using the new TCanvas3D Triangles method.
var Triangles : Array of TPointFloat;
X,Y : Array of Double;
... setup X and Y arrays with the coordinates of a polygon points….
// Calculate triangles:
// Draw the triangles:
New class function IsConvexPolygon.
Returns true when the passed P (array of points) parameter forms a “convex” simple polygon.
TPointFloat and TPoint3DFloat records fields are now of type Single instead of Double.
This was necessary for many reasons (FireMonkey, OpenGL in VCL, iOS and Android, speed, etc).
VCL only: Several methods have new overloads with Single parameters instead of Integer.
(MoveTo, LineTo, etc).
This is not necessary for FireMonkey as in FireMonkey all point coordinates are already of type Single.
New class procedure ResizeBitmap.
Passing a source and destination bitmap, GDI+ will be used to stretch the source bitmap onto destination bitmap using destination dimensions, in “high quality” mode.
New Scale property (Single, default = 1)
When <> 1, the chart size used to create the exporting image is internally scaled (reduced if Scale is < 1 or enlarged if Scale > 1). A Scale of value 0 is considered 1.
Multi-CPU Parallel Threads
Note: This is an experimental feature
A new TChart property enables internal usage of Thread objects to improve speed using multiple CPUs (when available).
One example is when using several FastLine series with many points, refreshing them at maximum speed, using several threads (one per series) might reduce the time spent calculating screen pixel positions.
// Use all available CPU processors to calculate all Series data in parallel.
procedure TForm1.CBParallelClick(Sender: TObject);
if CBParallel.Checked then
Image Export Formats
New property common to all picture exporting formats:
Scale (type Single, default 1)
Set Scale to create a picture bigger ( Scale > 1 ) or smaller ( Scale < 1 ) than the exported Chart dimensions.
JSON Export Format
New DateTimeFormat property to choose how to export series values that are datetime.
Default format is “jdTimestamp” (using Delphi RTL TDateTime).
Improved support for DateTime Series values.
Some classes with “virtual abstract” methods have now been marked as “class abstract” to prevent instantiating them by mistake. (Delphi 2009 and up).
TAntiAliasCanvas / TAntiAliasTool
As the default canvas is now GDI+, and GDI+ does a much better job anti-aliasing curves and diagonals, TAntiAliasCanvas has lost its initial sense and has been changed internally to use GDI+ canvas instead.
This can be overriden using a global project define and a “build all” : TEEANTIALIAS
There is at least one difference between the way GDI+ does antialias and TAntiAlias old code: horizontal lines are 2 pixel wide in GDI+ (probably due to half-pixel 0.5 coordinates).
LoadChartFromFile (TeeStore.pas unit) Chart parameter no longer passed by reference, so now its much easier to use, just calling it like: LoadChartFromFile( Chart1, ‘mychart.tee’)
Themes have been mostly converted to external *.tee files (inside the TeeThemes.res resource file). This ensures correct property settings when switching from one theme to another.
Zooming with Chart1.Zoom.KeepAspectRatio:=True has been improved.
FireMonkey Axis editor: New control to change Title.Position property.
Several new Series editors implemented in FireMonkey.
Fixed Legend Symbol display of Pointer series (Line, Point, etc) , preserving the aspect-ratio of Pointer size.
Improved display of Bar and HorizBar series rotated Marks when MarksOnBar := True (marks inside bars).
FireMonkey: Inverted order of FMXTee.Canvas TRGBA type fields.
Changed the signature of (internal) TCanvas3D Surface3D and TriSurface methods to include new parameters used by Surface and TriSurface series to “cache” drawing operations.
TSeriesTextSource: New property “TrimSpaces” (boolean, default True).
When True, consecutive spaces are removed between fields in the text source.
TSmithSeries: Big refactoring to reuse much code with TPolarSeries.
Themes: Refactored most themes, code converted to *.tee resource files.
TMaker units: Refactoring, moving the tessellation code to TGLCanvas.
New TTeeCPU class in TeeProcs (FMXTee.Procs) unit.
This class aims to provide information about the machine CPU, like NumberOfProcessors, Speed, Name, HasSSE instructions and so on.
Not all properties are available in all platforms, specially under iOS and Android.
This class also includes a ParallelFor method to invoke a “for” loop using multiple threads and processors.
This technical document describes all changes made to TeeChart component library (FireMonkey and VCL versions) since the release of May-21st 2013.
Internal canvas classes (GDI and GDI+) have been modified extensively. The default graphic canvas for new charts added at design-time is now GDI+ (TGDIPlusCanvas class) instead of GDI (TTeeCanvas3D class).
Switching from one canvas to another can be done at design-time and run-time through the TChart editor dialog (3D -> Render tab), or manually by code:
Using the TeeGDIPlus component allows persisting settings, like antialiasing and default text quality.
GDI+ offers several features that cannot be done with GDI (or are done better):
Color alpha (transparency)
Any color (pen, font, gradient, brush, etc) is now treated as a proper 32bit color with RGB and Alpha components.
The only limitation is pseudo-colors can't be used (clBtnFace, clWindow, etc).
Setting a color alpha transparency can be done at design-time using the chart editor dialogs.
Using IDE Object Inspector is also possible, but in VCL there is a limitation that TColor is a signed integer, and so values greater than MaxInt (2^31-1) cannot be manually typed (the Object Inspector raises an exception).
GDI+ has line antialias, which produces much better looking charts, without jagged diagonal and curved lines and polygon boundaries.
There's a speed penalty when using antialias that is not a problem unless you're plotting many many points and/or performing animations.
If not using a TeeGDIPlus component, Antialiasing can be changed at runtime by code like:
TGDIPlusCanvas(Chart1.Canvas).AntiAlias := False
The base TTeePen class has a new Fill property (of type TTeeBrush) that is only functional when using the GDI+ canvas. Wide borders and lines (of width 2 or more) can now be filled with textures and gradients.
Series1.Pen.Fill.Gradient.Visible := True
The GDI+ canvas allows gradients with more than 3 colors.
The base TTeeGradient class has a new Colors collection property. Each color item in the collection has Offset and Transparency properties:
Chart1.Gradient.Colors.Add( 0.3, clGreen, 50) // 0.3 means 30%, 50% is transparency
GDI+ uses brush images to fill polygons, rectangles and rounded rectangles with better speed and output results than GDI.
Rotating, translating and scaling elements (like chart titles, legend, series, etc) are enabled using GDI+ transform methods.
When filling polygons with gradients or textures, or when drawing rounded-corner rectangles, clipping should be done manually in GDI (which is not 100% perfect), while in GDI+ this is done automatically and better.
In GDI canvas, "smooth" shadows are painted using an intermediary bitmap with a "blur" filter applied. This is a very slow operation, although the output is quite good.
In GDI+, there's another approach to draw smooth shadows that is way much faster with a little loss in quality. Shadows are done using gradients and transparency.
GDI+ speed penalty
There's one thing that is much faster to paint in GDI than GDI+: non-solid pen lines.
Due to this, a big decision has been taken: axis grid lines are now solid instead of dotted:
Chart1.Axes.Left.Grid.Style := psSolid;
Grid lines can easily be changed again to be non-solid, using the axis editor dialog or Object Inspector.
With all the new changes, the GDI+ canvas is now faster than GDI in many occasions, as soon you use any effect like transparency, gradient fills, or shadows.
GDI is still faster than GDI+ when you dont need antialiasing and any fancy effect, for example when plotting FastLine or Surface series with many many points, but the difference between them is now much smaller, and you can always set back to GDI canvas.
As FireMonkey is already using GDI+ or Direct2D in Windows (and Quartz/OpenGL and the new GPU canvas for Mac OSX and iOS), the above list of GDI+ advantages for VCL are also valid for FireMonkey.
VCL and Firemonkey:
TTeeGradient Colors collection property
Gradients can be now configured to use multiple colors in FireMonkey and also in VCL with GDI+ canvas (the limit was three colors maximum with VCL GDI).
Each color item has Color, Offset and Transparency properties.
New Fill property (of type TTeeBrush) for VCL GDI+ and FMX, to paint line interiors using gradients or texture images:
New class methods to set and get the "Alpha" transparency (from 0 to 255) of a given color:
ColorAlpha(const AColor: TColor): Byte; // Returns "Alpha" byte from color
ColorFrom(const AColor: TColor; Alpha:Byte): TColor; // Sets "Alpha" to color
New method to draw a round rectangle in 3D (GDI+ only)
New ITeePath interface and TeeCanvas CreatePath method to fill and/or stroke "paths" using the current Pen and Brush/Gradient properties.
Automatic font quality for GDI+. When a font object "Quality" property is "default" (gpfDefault), the Canvas FontQuality is used.
For GDI+ canvas, the default font quality is now automatic, depending on the font size it is selected as "ClearType" (small fonts up to size 20), and "Best" for bigger font sizes. This gives the best combination of qualities and avoids "blurring" text.
You can always force a specific quality per-Canvas (global to all fonts), and also to a specific font object (ie: Chart1.Legend.Font.Quality)
The TTeeAnimate and TAnimation classes have been completely rewritten to provide smooth animations using a separate thread, and with more precision.
Animations are now configured in milliseconds instead of number of frames, using the Duration property.
The TTeeAnimate.Speed property defines the desired maximum number of frames per second (by default 60).
Frames that can't be painted are skipped.
New TAnimation Timing property.
Defines the interpolation function used to calculate each animation frame.
Values are: Linear, Sine, Square, Cubic. (Back, Bounce and Elastic)
New TimingStyle property to customize the timing acceleration: atIn, atOut, atInOut
New StartTime property, in milliseconds.
DurationFrames function returns the expected number of frames, according to Animate.Speed property (the desired maximum number of frames per second).
TwoWay boolean property (performs the animation and the inverted animation in the same amount of time)
Inverted boolean property. The animation performs as opposite.
Existing animations in previous versions (Expand and SeriesAnimation) no longer use TTimer components, they internally use the same TTeeAnimate system instead.
A generic "Animation" tool allows creating custom animations, composed of multiple items (individual animations with different properties) and a timeline.
Multiple Animation tools can be added and played simultaneously, each one with specific duration and settings.
Generic animations include NumberAnimation (to animate any integer, datetime or float property) and ColorsAnimation (to make color transitions, for any color property).
New Animations gallery with demos, and editor dialogs for all animation classes.
Animation classes include: Custom, Transform, Series, Expand and Random Points.
New support to animate all visible Series on a chart, by setting the Series property to nil to indicate all series should be animated.
Changing the global visual aspect of charts has been improved extensively.
Improved Themes Editor dialog with a visual gallery of available themes applied to the target chart:
New "Flat" theme, a minimal theme using "Roboto Th" font (the Android 4.x default font)
New methods at TThemesList class to apply any existing chart formatting as a theme for any other chart. In other words, any chart can be used as a "theme" for any other chart.
Only formatting is applied. That includes pens, brushes, gradients, fonts, etc.
Also any chart saved as a native *.tee file can be later reused as a "theme", and it will appear at the Themes Gallery.
Redesigned series gallery dialog, with a much better "sub" gallery to visualize different combinations for a single series style.
Sub-Gallery for Pie Series:
New TeeFunction gallery, with example demos of each function type.
When changing a series style using the gallery, styles that can't be applied appear disabled, now this is done internally using a gray-scale filter, which looks better and simplifies the code a good amount.
Improved Series display, for example now the Maps series (TWorldSeries class) show the map at the gallery:
New "Templates" tab at Gallery, with pre-defined Charts already using Series, Functions, Tools, etc.
For new Charts, a single click automatically adds a ready-to-use Chart:
New option to export Chart Series data to JSON format.
Available also at runtime:
OpenDocument Export format
The new TeeODS unit contains a class to export charts to OpenDocument (*.odt) spreadsheet format.
XAML export format now includes the optional "Transform" elements.
All Series Styles
The Transparency property (from 0 to 100%) has been moved to the base Series class (TChartSeries) and implemented for all series styles.
New Series.Marks AutoPosition boolean property (default True).
New protected Transform property (of type TTeeTransform)
New Series.Marks.SoftClip boolean property (default False).
When True, marks aren't displayed if their associated point is not inside the chart axes space (ChartRect).
Fill2D property (boolean, default False)
This new property, when True, draws the same filled arrows in 2D than in 3D.
Previously, in 2D mode arrows were always displayed with thin (no filled) lines.
Bar / HorizBar Series
All Bar styles use now Brush Gradient or Picture properties to fill interiors.
Implemented TickLines property for cylinder bar style in 2D and orthogonal 3D.
Automatic calculation of left and right margins
Bubble series now resizes the horizontal axis minimum and maximum values to accomodate for the first (left) and last (right) bubble points sizes, according to their radius.
This is controlled with the Pointer.InflateMargins property (default True).
Note: This only applies when the Bubble horizontal axis scales are also automatic.
Candle (OHLC) Series
Automatic Candle width
The AutoSize boolean property (default True) calculates the appropiate (best fit) Candle width according to the available horizontal space and the number of candles to visualize.
Removing gaps (weekends, bank holidays, etc)
When adding Candle data passing the "X" horizontal value as DateTime, the axis will display gaps (holes) for periods where there is not data (for example weekends).
The best solution to this problem, when possible, was to pass the "X" coordinate as a sequential integer number, thus making candles adjacent.
There is a new Candle method now to add data without the need to pass the "X" value:
Candle1.Add( Date, Open, High, Low, Close)
This method will internally convert Date to string, and pass a sequential "X" value.
Another different way to remove gaps is setting this new property to True:
Candle1.RemoveGaps := True
HighLowColor property (default "cbUseColor"). When "cbSameAsCandle", the High-Low line is painted using the same color as the candle, and the properties of the HighLowPen property.
BorderColor property (similar to the above) to paint the candle border using the Pen properties and the same color as the Candle.
Fixed bug in Clicked method.
New Hours, Minutes and Seconds property (TClockHand type)
The TClockHand class defines how to draw the clock hands with several properties, including border and background attributes, visibility and the percentages of radius, width, height, ending arrow.
New Center property (TSeriesPointer type), to display a shape at clock center (by default a circle).
New CustomTime and Time properties. When CustomTime is True, the clock no longer refreshes every second and remains static using the Time property.
BoxTransparency property (default 70%)
This property draws the Darvas boxes with transparency, and its independent from the Candle Transparency property.
Double Horiz. Bar Series
New Series, similar to Horizontal Bar series to show double values for each bar (one at Left and one at Right).
New DrawStyle property (default flSegments)
When setting it to "flAll", a single polyline call paints all series points instead of painting one by one.
Note: Null values are not considered in "flAll" mode.
FastPen with GDI+ disables antialias.
When using GDI+ canvas, setting FastPen to True will disable antialias to paint just the FastLine series.
This gives much more speed for large quantity of points, without sacrificing quality for all the other chart elements and series.
New Callout property to draw arrows at gantt bar connection lines.
Improved drawing calculations and new ShapeStyle property to optionally fill the gauge background.
Horizontal Bar Series
When showing individual bar values at Legend, the Legend is now inverted to show them in the same vertical order.
Line, Area, Point Series (and derived series from TCustomSeries)
New Pointer.Items property
Series Pointers can now be customized individually, for example:
When a pointer item has been modified, changes to the global Series1.Pointer property will not be used.
To reset a pointer item to its default values, set to nil:
Series1.Pointer := nil
To remove all custom pointer items completely, call Clear:
New TSeriesPointer FullGradient boolean property (default False)
New psDonut style for TSeriesPointer.Style property.
Line and Area Series
New DrawStyle property (default dsSegments).
Only for 2D and 3D orthogonal view modes. When DrawStyle is "dsAll", the line or area is displayed using a Canvas PolyLine / Polygon call instead of drawing each segment individually.
When DrawStyle is "dsCurve", and only for GDI+ canvas, the line is displayed using a smoothing spline algorithm.
When DrawStyle is not "dsSegments", this allows for example configuring the Pen.Gradient so the whole line uses the gradient colors, instead of using the gradient colors for each segment (segments between each line point), and also using the Pen.JoinStyle property to draw the connections between points.
Pie and Donut Series
New property Series1.PieMarks.Rotated (boolean) to display rotated marks (work also with PieMarks.InsideSlice:=True):
New value for MultiPie property (Series1.MultiPie := mpConcentric) to display multiple pie series as concentric donuts, in 2D and 3D.
New PieMarks.EmptySlice boolean property (default False). When True, series marks for empty pie slices (of value 0) will be displayed.
Polar, PolarGrid, Radar, Clock, WindRose and Rose Series
New AngleLabels property, merges and replaces all CircleLabelsXXX properties.
New AntiOverlap property automatically calculates the best increment between circle labels.
Horizontal Axis Ticks and MinorTicks are now displayed, when Visible.
Several display improvements (using floating point coordinates to avoid pixel-rounding errors)
Values at Legend are inverted to vertically align with pyramids.
Multiple Pyramid series display now at the same "Z" depth position.
Implemented Transparency support
Improved calculation of left and right margins when the Volumen Pen is big (wide).
Surface, ColorGrid, TriSurface, etc:
Palette colors (when UseColorRange is True), now support Alpha (transparency) which gets interpolated when calculating the color for each cell that corresponds to cell's value.
Series1.StartColor := TTeeCanvas.ColorFrom( clRed, 128); // Alpha from 0 to 255
New CircleBrush property to paint backgrounds using gradients and textures.
(This applies to Circled derived series like Polar, Radar, Rose, Clock, etc)
World Maps Series
New EurAsia map (combines Europe and Asia)
New Wall RoundSize property.
Walls (specially the back wall) can now be displayed as rounded rectangles.
Image filters can be applied to a TChart itself (using the internal canvas buffer Bitmap).
The Chart Editor dialog (General -> Mouse tab) has been enhanced with more options to control what happens when the mouse wheel is dragged.
New ZoomWheel property (of type TMouseWheelStyle) to allow zooming the whole chart (in 3D / Orthogonal modes) by dragging the mouse wheel.
New Zoom.MouseWheel property (of type TMouseWheelStyle) to allow zooming series data by dragging the mouse wheel.
This function calculates the cumulative percent (from 0 to 100%) of its source series values.
A new Pareto template at "Chart Gallery -> Templates" dialog, uses this function.
This function calculates the "center of gravity" XY point of its source series point XY positions.
Centroid position is the average position of all points in the array.
New tool TRepaintMonitor is an annotation that paints the current "Frames per second" speed when the chart is being animated or repainted lots of times.
New AllowDrag new property, bands can be dragged using the mouse.
New OnDragging event. Called while dragging the ColorBand using the mouse.
New OnResizing event. Called while dragging the ColorBand Start or End edge lines using the mouse.
New NoLimitDrag boolean property (default True) to allow dragging the color band outside the axis min <--> max limits.
TColorLineTool (and also Start and End lines of TColorBandTool) new property: Annotation. To display text located at line.
New AnnotationValue boolean property, when True it displays the current line value using axis formatting, using the Annotation properties.
New AxisAnnotation property, to display the current cursor position near the axis.
New FullRepaint property (default False). When True, the whole chart is repainted while dragging the cursors.
New RotateGradient property. When the arrow gradient is visible, gradient is rotated following the Arrow.Angle property.
New Align property, to align the scroller to bottom/right ("saAfter"), or to top/left ("saBefore"), or "saCustom" for custom positioning of the scroll pager sub-chart.
New NoLimitDrag boolean property (default False) to restrict scroll to main chart axis minimum and maximum.
New automatic vertical alignment, when using it with "Horizxxx" series like HorizArea or HorizBar.
New AddSeries and RemoveSeries methods, to customize which series should appear at the scroller chart, now allowing displaying multiple series (as you wish).
Data changes in the main series are now reflected in the scrollpager chart series.
New Pointer property, to draw an indicator near the legend palette. It is not visible by default, and has a "Value:Double" property you can set to the desired position in palette range:
For example, using a Surface series1, and a SurfaceNearestTool OnSelectCell event:
procedure TMainForm.ChartTool3SelectCell(Sender: TObject);
if LegendPalette1.Pointer.Visible then
When moving the mouse over the series, this event is triggered and the legend palette will paint the pointer indicator using the selected cell Value and Color.
New OriginPen property (TTeeHiddenPen) to optionally draw a line at Origin
New TChartAxis.SubAxes property (of type TChartAxes collection) allows nested-chain axes that are synchronized and displayed aligned to their parent axis.
SubAxes can be customized with specific Increment (step between labels) and display properties (labels formatting, text, ticks, etc).
SubAxes can be added and customized at design-time using the IDE Object Inspector (using the collection editor on any Axis SubAxes property) or using the TeeChart Editor dialog.
At runtime, example:
var MyAxis : TChartAxis;
New axis Texts subproperty. This property groups all the "Labelsxxx" properties into a single common object.
New axis Texts.Position property, determines where to display an axis label in the direction of the axis.
For example, in the sub-axis chart above, the year labels (2013, 2014, etc) are set to Texts.Position := lpAfterTick.
The default Position is "lpAtTick" (exactly centered at the label tick position).
New Shape property of type TTeeShape. When Shape.Transparent is False, the area surrounding the axis labels is filled:
New Texts.Format property, to draw boxes around axis labels, hidden by default:
New GlobalTransparency property
This property controls the total Legend transparency, including symbols and texts.
The already existing Transparency property is only used when filling the legend background.
New Zoom.FullRepaint boolean property (default False).
When true, the zoom rectangle displayed while dragging the chart will repaint the whole chart at each mouse movement.
This allows filling the zoom rectangle with brush color or gradients (for example semi-transparent gradients).
Repainting the whole chart takes some cpu time, but for normal charts this is a very small cost.
Many editor dialogs have been restructured and improved. There are many more "visual" galleries to customize properties.
Many modal dialogs have been replaced with embedded versions (modal dialogs aren't suitable for touch devices).
New EditTool method (at TeeEditTools unit) to show a modal dialog to edit a single tool component.
TeePicture Filters editor dialog now includes a live color histogram chart updated when changing filter parameters.
All these changes in editor dialogs are reused in TMaker and TTree component editors.
Transform (GDI+ canvas only)
A new protected property intended to be used by the new TransformAnimation, but that can also be manually configured.
Transform includes subproperties for translation, scaling and rotation.
All elements (Title, Legend, Series, etc) will apply their Transform by passing it to GDI+ canvas.
Displaying semi-transparent gradients over background pictures.
Gradients with semi-transparent colors (GDI+ canvas only) can be painted over pictures (for example Chart1.BackImage, or any other element like Chart1.Legend.Picture).
The following new features apply to all elements derived from this class (Annotations, Chart Legend, Chart Titles, Series Marks, Organizational series items, Numeric Gauge Markers, TreeMap series items, and many other derived classes).
New property "ShapeCallout", to draw call-out shapes at rectangle sides, with properties to configure the callout (size, position, etc).
TTeeCustomShape new property "Corners" (of type TTeeCorners) to indicate which of the four corners of a rectangle should be displayed using the "RoundSize" property (arcs). Default Style for all four corners is "dsRound".
New Children property (Collection). Multiple sub-items can be displayed inside the same element, recursively.
Each sub-item has individual formatting properties, font and text.
New ChildLayout property. Determines how to align Children sub-items inside the parent boundaries (Top-to-Bottom or Left-to-Right)
New Angle property (rotation degrees from 0 to 360)
Several improvements in TeeChartOffice free standalone application, including a Welcome page, Functions and Samples gallery, and all new features from TeeChart Pro library.
TeePointerDrawLegend global method.
Some minor fixes to improve displaying pointers with big wide border pens.
Area series fix, transparency in 3D for the last Area segment.
Bar, HorizBar series: Cylinder improvements (more smooth look) and better positioning of Marks inside Bars (MarksOnBar property).
New TFilterItems OnChange event (to notify for example at Filters Gallery dialog to repaint the preview filtered image).
TTeePen new Fill property (VCL GDI+ and FireMonkey only)
TTeeBrush Image property is now of type TTeePicture instead of TPicture (TTeePicture provides image filtering, like contrast, blur, etc)
TTeeFont.SizeFloat property (VCL only, GDI+) enables fine graining of font sizes.
TTeeFont.Brush property, supersedes Gradient and Picture properties.
New image filters: Sobel and Sepia.
New TBackImage Bottom and Right properties, to draw Chart1.BackImage at a custom rectangle.
New TTeeCanvas StretchQuality property (default sqHigh), to eliminate slow calls to SmoothStretch in GDI+.
New Chart1.SetChartRect(const R:TRect) method. To customize the axes rectangle boundaries.
Other internal changes
The units TeeToolsGalleryDemos and TeeAnimationsGalleryDemos have been moved from design-time package (DCLTEExx) to the runtime package (TeeProxx)
Some methods parameters have been prefixed with the "const" attribute (iOS related).
The Canvas BeginEntity method now accepts an optional "Transform" parameter.
TChartPen renamed to TTeePen (TChartPen still available)
TChartBrush renamed to TTeeBrush (TChartBrush still available)
TAxisGridPen, changed default pen style to "psSolid" and width to "0" (thin solid lines)
TTeeZoom.Pen.Width changed default to 3 pixels, for better visibility on big screens.
TSeriesAnimationTool has been moved from TeeTools unit to TeeAnimations unit.
New FontQuality protected property for GDI canvas, to change the global default font quality for all fonts. (This is similar to GDI+ canvas AntiAliasText property).
Improved TButtonColor, TButtonPen and TButtonGradient painting symbol when Caption is empty.
Default Font Size for iOS applications, changed from 15 to 11.
All TChartAxis "LabelsXXX" properties are now grouped into a new Texts subproperty of type TAxisLabels.
Croatia country added to "Europe 28" map. (Renamed from "Europe 27").
Improved display of rotated multi-line Text shapes (Marks, Annotation tools, etc).
More improvements to TeeHTML methods (to display tagged html text inside shapes).
TSurfaceSeries, HideCells property now defaults to True instead of False.
TTeeCanvas.PyramidTrunc parameters changed from Integer to Double.
TCustomBarSeries AutoMarkPosition, replaced with Marks.AutoPosition property.
TPieSeries AutoMarkPosition, replaced with Marks.AutoPosition property.
TTeeFont.Gradient.Outline deprecated, replaced with TTeeFont.Outline.Gradient.
TTeeCanvas Pen, Font and Brush are no longer inherited from VCL/FMX TCanvas.
$IFDEF MONITOR_REPAINTS removed. Replaced with TRepaintMonitor tool.
TTeeShadowEditor global InsertTeeShadowEditor function replaced wih class function TTeeShadowEditor.InsertForm.
TTeeEmbossEditor unit and class removed as it was redundant. Use TTeeShadowEditor.
The protected TChartSeries method "PrepareForGallery" no longer has the IsEnabled parameter.
ColorToRGB is no longer internally used. All Colors are considered 4 bytes in RGBA format.
Only a single TCanvas3D.TextOut overload method is now virtual.
TAnnotationTool CalcTextSize protected virtual method deprecated. See new TTextShape.CalcBounds.
TTextShape DrawRectRotated method renamed to simple "Draw" (several overloads)