Spark lines for macros, iOS and tvOS

A lightweight Sparkline component that supports Swift, SwiftUI, MacCatalyst and Objective-C.

Characteristics

  • Supports multiple chart styles, such as . B. Line, beam, slate, etc.
  • Supports spark line settings such as zero line, grid lines, backlight.
  • NSView/UIView/SwiftUI types ready for quick integration.
  • Independent scalability for sparks of any size
  • The y range can be automatically increased or decreased to cover the entire y range of the data.
  • Range Y can be specified and the spark line will be truncated to the specified range.
  • SwiftUI support for all types of sparks
  • IBD supports pre-built types, so you can see and customize your spark lines in the Interface Builder.
  • Additional drawing of the zero line in bar and line graphs (with thanks to Tito Churo)
  • Playground support
  • NSA string support

TL;DR – Show me something!

Create a map of the retina (144 dpi) with a simple line drawing
// Data source with a simple dataset
let source = DSFSparkline.DataSource(values: [4, 1, 8, 7, 5, 9, 3], range: 0 … 10).

let bitmap = DSFSparklineSurface.Bitmap() // Create a
bitmap surface let stack = DSFSparklineOverlay.Line() // Create a
bitmap overlay stack.dataSource = source // Assign the data source to the
bitmap overlay.addOverlay(stack) // And add the overlay to the surface.

// create an image with retinal scale
let image = bitmap.image (width: 50, height: 25, scale: 2)

// Sparkline insertion in NSAttributedString
allowed attributedString = bitmap.attributedString(size: CGSize(width: 40, height: 18), scale: 2)

SwiftUIDemoDataSource lets you create lines of Swift UI images from scratch and mark areas that overlap with the
– private : DSFSparkline.DataSource = {
lets d = DSFSparkline.DataSource(windowSize: 20, range: 0 … 1, zeroLineValue: 0.5)
d.push(values: [
0.72, 0.84, 0.15, 0.16, 0.30, 0.58, 0.87, 0.44, 0.02, 0.27,
0.48, 0.16, 0.15, 0.14, 0.81, 0.53, 0.67, 0.52, 0.07, 0.50
])
return d
}()

SuperCoolLineSpark Structure : View {
// Overlay representing the zero line for data source
var zeroOverlay : DSFSparklineOverlay = {
let zeroLine = DSFSparklineOverlay.ZeroLine()
zeroLine.dataSource = SwiftUIDemoDataSource
zeroLine.dashStyle = [] return zeroLine
}()

// Overlay to mark the range 0 ..< 0.2
var rangeOverlay : DSFSparklineOverlay = {
let highlight = DSFSparklineOverlay.RangeHighlight()
highlight.dataSource = SwiftUIDemoDataSource
highlight.highlightRange = 0.0 ..< 0.2
highlight.fill = DSFSparkline.Fill.Color(DSFColor.gray.withAlphaComponent(0.4).cgColor)
return highlight
}()

// Diagram of the actual line
var lineOverlay : DSFSparklineOverlay = {
lets lineOverlay = DSFSparklineOverlay.Line()
lineOverlay.dataSource = SwiftUIDemoDataSource

lineOverlay.primaryStrokeColor = DSFColor.systemBlue.cgColor
lineOverlay.primaryFill = DSFSparkline.Fill.Color(DSFColor.systemBlue.withAlphaComponent(0.3).cgColor)

lineOverlay.secondaryStrokeColor = DSFColor.systemYellow.cgColor
lineOverlay.secondaryFill = DSFSparkline.Fill.Color(DSFColor.systemYellow.withAlphaComponent(0.3).cgColor)

lineOverlay.strokeWidth = 1
lineOverlay.markerSize = 4
lineOverlay.centerAtZeroLine = true

return stringOverlay
}()

var body : some View {
DSFSparklineSurface.SwiftUI([
rangeOverlay, // overlay highlight range
zeroOverlay, // zero overlay
lineOverlay, // line chart overlay
])
.frame(width : 150, height : 40)
}
}

You can find many examples of sparklines in projects in the Demonstrations/examples subfolder.

A simple Xcode playground is available in the Demo/Playground subfolder.

Overlapping use

There are three basic elements to producing a spark. Overhead lines are more flexible and customizable than prebuilt views, but they are more complex to configure and do not support @IBDesignable.

  • The surface – where she’s going to draw
  • Data source – fixed value for the drawing
  • One or more overlays – layers that visualize the different components of the spark line.

Using preset screens

The pre-built view is useful for quickly adding a spark via Interface Builder (when previewing with @IBDesignable) or SwiftUI. These views provide a hard-coded style (more than a simple map color) and a set of marginal parameters.

  • Data source – fixed value for the drawing
  • Prebuilt view – NSView/UIView/SwiftUI view to draw your spark line.

If you used sparklines from DSFS before version 4, these are the original display types you used to display your sparklines.

Area

The area indicates the purpose of the spark bridge. This library offers a number of integrated interfaces

  • DSFSparklineSurfaceView – NSView/UIView interface for the Sparkline screen.
  • DSFSparklineSurface.SwiftUI – SwiftUI view surface.
  • DSFSparklineSurface.bitmap – NSImage/UIImage/CGImage/NSAttributedString interface to create a bitmap of a sparkline.

Data source

The data source provides the data for the spark line. A data source can be divided into several overlays or predefined types (see below) to provide different views of the data in the source. And when the DataSource is updated, all spark ovals observing that source are automatically returned.

Currently, there are two types of data sources.

DSFSparkline.DataSource

DataSource that contains values that can be updated by adding new values to the source.

Further information

Window size

DataSource determines the size of the window – the maximum number of values that will be drawn on the overlay. When you enter values into the DataSource, values that no longer fit in the DataSource window are rejected.

  • When the window size is reduced, the recorded data is truncated.
  • When the window size is increased, the data memory is filled with zeros.

Sample code
//// Swift
dataSource.windowSize = 30
assert(dataSource.windowSize == 30)

//// purpose-C
[dataSource setWindowSize:30];
assert([dataSource windowSize] == 30) ;

Y Band

The interval determines the upper and lower values displayed in the spark line. All values entered in the data source are limited to this range when drawing.

If the range is not specified (i.e. zero), all overlays are automatically adjusted to cover the full range of values in the source code. For example, for values [1, 2, 3, 4], the range is implicitly set to 1 … . 4. If the values are [-10, 100, 33], the range is implicitly set to -10 … . 100

Example code
//// Swift
dataSource.range = -1.0 … 1.0

//// Target-C
[dataSource setRangeWithLowerBound:-1,0 upperBound:1,0] ;

Zero value

The zero line indicates the point where the spark gaps should count as zero. For example, graphs that can be centered (row, column, and stack row) use the value of the zero line to determine where the graph is centered on the circle.

The default value is zero.

You can draw a zero line for the spark by adding DSFSparklineOverlay.ZeroLine to your surface.

Sample code
//// Swift
dataSource.zeroLineValue = 0.2

/// Aim-C
[dataSource setZeroLineValue:0.2] ;

Add values

The push functions allow you to enter new values into the data source. Values in the data source older than the sourceSize window are rejected.

When values are entered into the data source, all overlays assigned to that data source are automatically updated.

Example code
//// Swift
dataSource.push (value: 4,5)
dataSource.push (values: [6, 7, 8])

/// Target-C
[dataSource pushWithValue:@(4.5)] ;

All values in the data source are replaced by the functions in the set. The set function also changes the window size (windowSize) of the data source to match the size of the transmitted value table.

Any overlay assigned to this data source is automatically updated.

Example code
//// Swift
datasource.set(values: [
0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0,
0.0, -0.1, -0.2, -0.3, -0.4, -0.5, -0.6, -0.7, -0.8, -0.9, -1.0
])

/// Objective-C
[Set of data sourcesC with values :
@[@(0.0), @(0.1), @(0.2), @(0.3), @(0.4), @(0.5), @(0.6), @(0.7), @(0.8), @(0.9), @(1),
@(0.0), @(-0.1), @(-0.2), @(-0.3), @(-0.4), @(-0.5), @(-0.6), @(-0.7), @(-0.8), @(-0.9), @(-1)]] ;

DSFSparkline.StaticDataSource

A data source that contains a static set of values. Some types of Sparkline use one record with no historical context.

Plus
//// Swift
let dataSource = DSFSparkline.StaticDataSource([1, 2, 3])

/// Target-C
DSFSparklineStaticDataSource* dataSource = [[DSFSparklineStaticDataSource alloc] init : @[@(1), @(2), @(3)]] ;

Overlays

The overlays are separate visual elements of the spark bridge. You can add as much or as little as you like in any order to your surface. For example, for example… For example, it is possible to place two different types of diagrams on the same surface. And because overlays can use the same data source, all overlays that use the same data source are automatically updated when the data changes (for example, in response to a click).

For example, there is an overlay that allocates data in the range of y. If you need grid lines, you can add them with a grid line overlay.

You can add several overlay instances to the same spark line. If you z. B. To add multiple selections, add multiple selections to the spark zone.

The order in which the overlays are added determines where, in z-order, they appear in the spark line. For example, you can B. If desired, draw a grid on the graph by adding an overlay to the graph BEFORE adding an overlay to the grid.

With overlaying, your spark field can be as complex or as simple as you like.

Diagram types

Dynamic

The dynamic graph automatically updates its overlays when values are transferred to its data source. When data is added, the assigned overlay is automatically updated with the new data. When additional data is added by clicking or typing, the corresponding view is automatically updated with the new data. Older data that is no longer in the data source window is deleted.

Allows you to display all historical data across the full width of the chart.

`DSFSparklineOverlay.Line`
let bitmap = DSFSparklineSurface.Bitmap() // Create bitmap overlay
let line = DSFSparklineOverlay.Line() // Create line overlay
line.strokeWidth = 1
line.primaryFill = primaryFill
line.dataSource = source // Assign the data source to the overlay
bitmap.addOverlay(line) // And add the overlay to the surface.

// Create a retina scale image
let image = bitmap.image (width: 50, height: 25, scale: 2) !

// Do something with the image

`DSFSparklineOverlay.StackLine`
let bitmap = DSFSparklineSurface.Bitmap() // Create a
bitmap overlay let stack = DSFSparklineOverlay.Stackline() // Create a
stackline overlay.dataSource = source // Assign the data source to the overlay
stack.strokeWidth = 1
stack.primaryFill = primaryFill
bitmap.addOverlay(stack) // And add the overlay to the surface.

// Create a retina scale image
let image = bitmap.image (width: 50, height: 25, scale: 2) !

// Do something with the image

`DSFSparklineOverlay.Bar`
let bitmap = DSFSparklineSurface.Bitmap() // Create a bitmap surface
let bar = DSFSparklineOverlay.Bar() // Create an overlay bar
bar.dataSource = source // Assign a data source to the overlay
bar.primaryFill = primaryFill
bitmap.addOverlay(bar) // And add an overlay to the surface.

// Create a retina scale image
let image = bitmap.image (width: 50, height: 25, scale: 2) !

// Do something with the image

`DSFSparklineOverlay.Dot`
let bitmap = DSFSparklineSurface.Bitmap() // Create a bitmap overlay
let dot = DSFSparklineOverlay.Dot() // Create an overlay
dot = bigersource // Assign a data source to the overlay
bitmap.addOverlay(dot) // And add an overlay to the overlay.

// Generate a retinal image
let image = bitmap.image (width: 50, height: 32, scale: 2) !

// Do something with the image

`DSFSparklineOverlay.WinLossTie`
let bitmap = DSFSparklineSurface.Bitmap() // Create bitmap overlay
let winLossTie = DSFSparklineOverlay.WinLossTie() // Create winloss overlay
winLossTie.dataSource = winloss // Assign the data source
bitmap.addOverlay(winLossTie) // And add the overlay to the surface.

// Create an image with retina scale
let image = bitmap.image (width: 75, height: 12, scale: 2) !

// Do something with the image

`DSFSparklineOverlay.Tablet`
let bitmap = DSFSparklineSurface.Bitmap() // Create bitmap overlay
let stack = DSFSparklineOverlay.Tablet() // Create tablet overlay
stack.dataSource = winloss // Assign data source to overlay
bitmap.addOverlay(stack) // And add the overlay to the surface.

// Create an image with retina scale
let image = bitmap.image (width: 90, height: 16, scale: 2) !

// Do something with the image

`DSFSparklineOverlay.Stripes`
let bitmap = DSFSparklineSurface.Bitmap() // Create bitmap surface
let stack = DSFSparklineOverlay.Stripes() // Create superimposed stripes
stack.dataSource = .init(values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
bitmap.addOverlay(stack) // And add an overlay to the surface.

// create an image with retinal scale
let image = bitmap.image (width: 90, height: 16, scale: 2)

// Do something with the image

Static

A static graph has a fixed set of values (for example, a pie chart). Overlays are updated when a new static data source is assigned.

`DSFSparklineOverlay.Pie`
let bitmap = DSFSparklineSurface.Bitmap()
let pie = DSFSparklineOverlay.Pie()
pie.dataSource = DSFSparkline.staticDataSource([10, 55, 20])
pie.lineWidth = 0.5
pie.strokeColor = CGColor.black

bitmap.addOverlay(cake)

// Create an image with retina scale
let image = bitmap.image (width: 18, height: 18, scale: 2) !

// Do something with the image

`DSFSparklineOverlay.DataBar`
let bitmap = DSFSparklineSurface.Bitmap()
let stack = DSFSparklineOverlay.DataBar()
stack.dataSource = DSFSparkline.staticDataSource([10, 20, 30])
stack.lineWidth = 0.5
stack.strokeColor = CGColor.black

bitmap.addOverlay(stack)

// Generate a retinal image
let image = bitmap.image (width: 50, height: 18, scale: 2) !

// Do something with the image

Component types

The component is an overlay that is not itself an image. Examples: Grid lines, zero lines, mirror reflections, etc. The component uses the same data source, so it matches the graph to which it is linked.

Name Description
DSFSparklineOverlay.ZeroLine Draw a horizontal line at the location of the zero spark line. The zero line is determined by the data source and is zero by default, but can be changed.
DSFSparklineOverlay.RangeHighlight Mark the value range y on the spark plug line
DSFSparklineOverlay.GridLines Draw lines according to the y-values given on the spark line

Available types of prefabricated products

  • DSFSparklineLineGraphView / DSFSparklineLineGraphView.SwiftUI
  • DSFSparklineStackLineGraphView / DSFSparklineLineGraphView.SwiftUI
  • DSFSparklineBarGraphView / DSFSparklineBarGraphView.SwiftUI
  • DSFSparklineStripesGraphView / DSFSparklineStripesGraphView.SwiftUI
  • DSFSparklineDotGraphView / DSFSparklineDotGraphView.SwiftUI
  • DSFSparklineWinLossGraphView / DSFSparklineWinLossGraphView.SwiftUI
  • DSFSparklineTabletGraphView / DSFSparklineTabletGraphView.SwiftUI
  • DSFSparklinePieGraphView / DSFSparklinePieGraphView.SwiftUI
  • DSFSparklineDataBarGraphView / DSFSparklineDataBarGraphView.SwiftUI

Example of Swift code

// create view
show sparklineView = DSFSparklineLineGraphView(…)
sparklineView.graphColor = UIColor.blue
sparklineView.showZeroLine = true

//Create a data source and assign the view
let sparklineDataSource = DSFSparklineDataSource(windowSize: 30, range: -1.0 … 1.0)
sparklineView.dataSource = sparklineDataSource

…

// add a new data point in sparkline
sparklineDataSource.push(value: 0.7) // the view is automatically updated with the new data.

// Record added to sparkline
sparklineDataSource.push(values: [0.3, -0.2, 1.0]) // The view is automatically updated with the new data.

// Replace the sparkline data completely with the new
sparklineDataSource.set (values: [0.2, -0.2, 0.0, 0.9, 0.8]) // The display is automatically reset to the new data.

Example of SwiftUI code
for the SparklineView structure : See {

leave the data source on the left side : DSFSparkline.DataSource
enables rightDataSource : DSFSparkline.DataSource

let BigCyanZeroLine = DSFSparkline.ZeroLineDefinition(
color : .cyan,
line width : 3,
lineDashStyle : [4,1,2,1] )

var body: some View {
HStack {
DSFSparklineLineGraphView.SwiftUI(
dataSource: leftDataSource,
graphColor: DSFColor.red,
interpolated: true)
DSFSparklineLineBarGraphView.SwiftUI(
dataSource: rightDataSource,
graphColor: DSFColor.blue,
lineWidth: 2,
showZeroLine: true,
zeroLineDefinition: BigCyanZeroLine)
}
}
}

Using preset screens

DSFSparkline has a number of pre-built Spark views with a narrower range that are designed to be inserted into your project faster, especially when used in conjunction with Interface Builder (the pre-built types provide an @IBDesignable interface), so you can design the look of your image directly from Interface Builder.

Each prefabricated glitter line view has a SwiftUI companion view.

Predefined parameters

Display types and parameters

Represents the visible parameters and display. Currently, the following types of displays are available: –

Common display parameters

Setting Type Description
graphColor NSColor
UIColor
The color to be used to draw the line of ignition.

Common elements for nautical charts capable of displaying a zero line (line/barrier/stack line)

Setting Type Description
dataSource DSFDataSource Source of data for the diagram
showZeroLine Boolean Draw a dotted line at the zero point on the Y axis.
zeroLineColor NSColor
UIColor
The color of the zero line on the Y axis.
Zero line width CGFloat Zero line width in the Y axis
zeroLineDashStyle CGFloat] Detail of the line used to draw the zero line.

Common elements for diagrams that can be centred on the zero line (line/line/stack)

Setting Type Description
CenterAtZeroLine Boolean Should the graph be centered on the zero line?
lowerGraphColor NSColor
UIColor
Color used to draw values below the zero line. If it’s a tie, it’s the same color as the card’s suit.

Structure of the line chart (DSFSparklineLineGraphView)

Simple line chart

Setting Type Description
dataSource DSFDataSource Source of data for the diagram
line width CGFloat Line thickness
Interpolation Boolean Interpolate the curve between the points
line shadow Boolean Shade the area below the line
shaded Boolean Draw a shadow below the line
markerSize CGFloat (Optional) Draw a marker of a certain size at each point on the graph, using the color of the line at that point.

Bar chart setting (DSFSparklineBarGraphView)

Simple bar chart

Setting Type Description
dataSource DSFDataSource Source of data for the diagram
line width CGFloat Line thickness
barSpacing CGFloat Distance between bars

StripesGraphView (DSFSparklineStripesGraphView)

Striped board. A good example of a band diagram is a warming band climate diagram.

The values of the data source are assigned to the provided gradient.

Setting Type Description
dataSource DSFDataSource Source of data for the diagram
Built-in Boolean If this is the case, stripes are drawn at the pixel boundaries to get nice sharp lines.
Gradient DSFGradient The color gradient used when matching data source values to colors.

Define DotGraphView (DSFSparklineDotGraphView)

A dotted box reminiscent of the Activity Viewer.

Setting Type Description
dataSource DSFDataSource Source of data for the diagram
looted Boolean If so, it is drawn from top to bottom.
unsetGraphColor NSColor
UIColor
Color used to draw the background

Configure P&L graph (DSFSparklineWinLossGraphView)

Profit graph, where positive values in the data source are represented as gains, negative values as losses, and zero values as draws.

Setting Type Description
dataSource DSFDataSource Source of data for the diagram
line width CGFloat Line thickness for the line
barSpacing CGFloat Distance between bars
winColor NSColor
UIColor
A color you can win with.
lossColor NSColor
UIColor
Color used for loss
tieColor NSColor
UIColor
(Optional) Color used for the tie. If the value is zero, DC values (0) are not drawn
By default, DC values are not drawn.

Tablet graph viewer (DSFSparklineTabletGraphView)

A flat-bottomed graph where positive values from the data source are indicated by a filled circle and negative values are indicated by an unfilled circle. The concept is identical to the profit/loss graph, only the display is different.

Setting Type Description
dataSource DSFDataSource Source of data for the diagram
line width CGFloat Line thickness for the line
barSpacing CGFloat Distance between bars
winColor NSColor
UIColor
Color to draw a filled circle to win.
lossColor NSColor
UIColor
Color to draw a filled circle for loss.

Pie chart configuration (DSFSparklinePieGraphView)

Setting Type Description
dataSource CGFloat] Data to be displayed in the pie chart
Pallet DSFSparking line pallet . Pallet used for drawing the diagram
strokeColor NSColor
UIColor
(Optional) Color of the line to be drawn between each segment. If the value is zero, no line is drawn.
line width CGFloat The width of the lines to be drawn between each segment.
animated Boolean If set to true, the segments are animated for viewing when the data source is set.
AnimationDuration CGFloat Duration of the animation

Most of these parameters are available both through the program and through @IBInspectable in the interface creator.

Configuring the database graph (DSFSparklineDataBarGraphView)

Setting Type Description
dataSource CGFloat] Data to be displayed in the pie chart
maxTotalValue CGFloat If <= 0, then the data represents the percentage of the total, if > 0, then the rightmost value in the database.
Pallet DSFSparking line pallet . The palette used in painting.
strokeColor NSColor
UIColor
(Optional) Color of the line to be drawn between each segment. If the value is zero, no line is drawn.
line width CGFloat The width of the lines to be drawn between each segment.
unsetColor NSColor
UIColor
(Optional) When set to the maximum value, if the segments do not match the overall color, the background color is used as the background color.
animated Boolean If set to true, the segments are animated for viewing when the data source is set.
AnimationDuration CGFloat Duration of the animation

Most of these parameters are available both through the program and through @IBInspectable in the interface creator.

Types of diagrams available

Line

Standard Centralised
interpolated Interpolated centre
Standard marker Interpolated flags

Bar

Standard Centralised

Stack line

Standard Centralised

Band

Standard Integral (pixel limits)

Item

Standard Reverse

Profit/loss

Gains/Losses Victory/Loss/Connection

Shelf

Standard

Pie

Standard

Database

Percentage Total

Integration

Demos are available in the demos subfolder for each of the supported platforms. The demos use CocoaPods, so you need to install the subsystem in the Demos folder.

Import the library into the source files

Coconut palms

pod DSFSparkline, :git => https://github.com/dagronf/DSFSparkline/.

Swift Package Manager

Add https://github.com/dagronf/DSFSparkline to your project.

Screenshots

Attached

dark macOS Mako lamp iOS

Interface creator

macOS Television

SwiftUI

Support for TV channels distributed by SLAs

Animated

Modifications

4.1.0

  • Sparks built into the TV channel distributed by the NSA.

4.0.0

Significant reworking of drawing code (which used to reside directly in views) into much more flexible overlays and interfaces (e.g. the ability to draw a spark line bitmap without having to create a view).

The previous View/Swiftui types are still available – they have been recreated with the new overlay scheme and are called pre-built types in the documentation. This allowed backward compatibility with earlier versions of the library. Note, however, that due to overwriting pre-built views, minor visual differences may occur.

3.7.0

3.6.1

  • Fixed animation on iOS/tvOS

3.6.0

  • Pie chart, database chart added.
  • Added ability to display data markers for line graphs

3.5.2

  • Fixed a bug in the Object-C demo application
  • Added a snapshot method to the base Sparkline View class to create an NSImage/UIImage version of sparkline for text embedded sparklines, etc.

3.5.1

3.5.0

  • Adding the battery spark plug type
  • Profit/Loss/Butterfly type added
  • Addition of the type of spark of the tablet

3.4.0

  • Added support for centering lines and histograms around their zero value.

3.3.0

  • Fixed an issue where the iOS background was sometimes poorly drawn.
  • Correction of a rare crash of the line graph at < 2 points.

3.2.0

  • The class of the zero line definition has been changed to DSFSparklineZeroLineDefinition for clarity.
  • More documentation, especially about SwiftUI. Trying to make the documentation more understandable in terms of drawing parameters.

3.1.0

  • Added ability to customize the display of the zero line (Tito Churo).
  • Changed from showZero to showZeroLine to display the new values for displaying the zero line.

3.0.0

  • Add an option to set the string value to zero. The default value is zero for backward compatibility.

You can use the zero line value on the data source to determine where the zero line is drawn.

2.0.0

  • The main views have been renamed with the postfix view. Like this,

DSFSparklineLineGraph -> DSFSparklineLineGraphView

DSFSparklineBarGraph -> DSFSparklineBarGraphView

DSFSparklineDotGraph -> DSFSparklineDotGraphView

  • Rename SLColor and SLView into DSFColor and DSFView to ensure consistent module names.
  • I removed windowSize from the DSFSparklineDataSourceView kernel. windowSize refers to data and should never have been part of the UI definition. I have provided a replacement for the IBDesignable support only called graphWindowSize, which should only be called by Interface Builder. If you want to define windowSize from an xib file, define graphWindowSize inspectable.

If you see warnings like
2020-12-07 18:22:51.619867+1100 iOS Sparkline Demo [75174:1459637] Failure of the definition (windowSize) of the user-defined inspected property on (DSFSparkline.DSFSparklineBarGraphView): [ setValue:forUndefinedKey : ]: This class does not match the encoding of the value of the windowSize key.
means that windowSize is defined in your .xib file. Remove it and set graphWindowSize instead.

  • For the bar type, lineWidth and barSpacing now display the spacing and width in pixels of the line. You may find that the line and bar spacing are now incorrect if you have set them to fractional values in the past (for example, if you set lineWidth = 0.5). The reason for this change is to help draw lines at the pixel limits and avoid anti-aliasing.
  • Correction of inverted zero line

GitHub

line chart in swift 5,chart objective c,circle chart in ios,ios geochart,coronatracker,swiftui pie chart,sample ios app for testing,examples of ios devices,ios sample projects with source code,ios animations swift,text animations swift,ios confetti animation swift,adobe xd ios ui kit for windows,ios ui kit figma,apple design principles,app icon template illustrator,ios symbols,ios 14 design ideas,vuetify sparkline y axis,doughnut chart vuetify,vuetify pie charts,vuetify apexcharts,vue-google-charts,vuetify step by step,Privacy settings,How Search works,ios example,sample ios app,sample xcode projects for iphone,custom controls for ios ipados macos tvos and watchos cocoa controls,swift example app

You May Also Like

How To Fix The User Profile Service failed the sign-in in Windows 10

There are many bugs in Windows 10 that can prevent you from…

How to Connect iPhone to Mac [5 Different Ways]

Connect your iPhone to your Macbook and you can transfer photos, contacts,…

How To Fix Computer Not Showing Up On Network Issue

With Windows 10, you can connect and access PCs connected to your…

How to Set Out of Office in Outlook [Automatic Reply]

Microsoft Outlook is the first choice when it comes to sharing email,…