plotly_patched/common/
mod.rs

1use serde::Serialize;
2
3pub mod color;
4
5use crate::common::color::ColorWrapper;
6use crate::private;
7use crate::private::{to_num_or_string_wrapper, NumOrString, NumOrStringWrapper};
8use color::Color;
9
10#[derive(Serialize, Clone, Debug)]
11#[serde(untagged)]
12pub enum Direction {
13    Increasing { line: Line },
14    Decreasing { line: Line },
15}
16
17#[derive(Serialize, Clone, Debug)]
18pub enum Visible {
19    #[serde(rename = "x")]
20    True,
21    #[serde(rename = "x")]
22    False,
23    #[serde(rename = "x")]
24    LegendOnly,
25}
26
27#[derive(Serialize, Clone, Debug)]
28pub enum HoverInfo {
29    #[serde(rename = "x")]
30    X,
31    #[serde(rename = "y")]
32    Y,
33    #[serde(rename = "z")]
34    Z,
35    #[serde(rename = "x+y")]
36    XAndY,
37    #[serde(rename = "x+z")]
38    XAndZ,
39    #[serde(rename = "y+z")]
40    YAndZ,
41    #[serde(rename = "x+y+z")]
42    XAndYAndZ,
43    #[serde(rename = "text")]
44    Text,
45    #[serde(rename = "name")]
46    Name,
47    #[serde(rename = "all")]
48    All,
49    #[serde(rename = "none")]
50    None,
51    #[serde(rename = "skip")]
52    Skip,
53}
54
55#[derive(Serialize, Clone, Debug)]
56pub enum TextPosition {
57    #[serde(rename = "inside")]
58    Inside,
59    #[serde(rename = "outside")]
60    Outside,
61    #[serde(rename = "auto")]
62    Auto,
63    #[serde(rename = "none")]
64    None,
65}
66
67#[derive(Serialize, Clone, Debug)]
68pub enum ConstrainText {
69    #[serde(rename = "inside")]
70    Inside,
71    #[serde(rename = "outside")]
72    Outside,
73    #[serde(rename = "both")]
74    Both,
75    #[serde(rename = "none")]
76    None,
77}
78
79#[derive(Serialize, Clone, Debug)]
80pub enum Orientation {
81    #[serde(rename = "v")]
82    Vertical,
83    #[serde(rename = "h")]
84    Horizontal,
85}
86
87#[derive(Serialize, Clone, Debug)]
88pub enum GroupNorm {
89    #[serde(rename = "")]
90    Default,
91    #[serde(rename = "fraction")]
92    Fraction,
93    #[serde(rename = "percent")]
94    Percent,
95}
96
97#[derive(Serialize, Clone, Debug)]
98pub enum Fill {
99    #[serde(rename = "tozeroy")]
100    ToZeroY,
101    #[serde(rename = "tozerox")]
102    ToZeroX,
103    #[serde(rename = "tonexty")]
104    ToNextY,
105    #[serde(rename = "tonextx")]
106    ToNextX,
107    #[serde(rename = "toself")]
108    ToSelf,
109    #[serde(rename = "tonext")]
110    ToNext,
111    #[serde(rename = "none")]
112    None,
113}
114
115#[derive(Serialize, Clone, Debug)]
116pub enum Calendar {
117    #[serde(rename = "gregorian")]
118    Gregorian,
119    #[serde(rename = "chinese")]
120    Chinese,
121    #[serde(rename = "coptic")]
122    Coptic,
123    #[serde(rename = "discworld")]
124    DiscWorld,
125    #[serde(rename = "ethiopian")]
126    Ethiopian,
127    #[serde(rename = "hebrew")]
128    Hebrew,
129    #[serde(rename = "islamic")]
130    Islamic,
131    #[serde(rename = "julian")]
132    Julian,
133    #[serde(rename = "mayan")]
134    Mayan,
135    #[serde(rename = "nanakshahi")]
136    Nanakshahi,
137    #[serde(rename = "nepali")]
138    Nepali,
139    #[serde(rename = "persian")]
140    Persian,
141    #[serde(rename = "jalali")]
142    Jalali,
143    #[serde(rename = "taiwan")]
144    Taiwan,
145    #[serde(rename = "thai")]
146    Thai,
147    #[serde(rename = "ummalqura")]
148    Ummalqura,
149}
150
151#[derive(Serialize, Clone, Debug)]
152#[serde(untagged)]
153pub enum Dim<T>
154where
155    T: Serialize,
156{
157    Scalar(T),
158    Vector(Vec<T>),
159}
160
161#[derive(Serialize, Clone, Debug)]
162pub enum PlotType {
163    #[serde(rename = "scatter")]
164    Scatter,
165    #[serde(rename = "scattergl")]
166    ScatterGL,
167    #[serde(rename = "scatter3d")]
168    Scatter3D,
169    #[serde(rename = "bar")]
170    Bar,
171    #[serde(rename = "box")]
172    Box,
173    #[serde(rename = "candlestick")]
174    Candlestick,
175    #[serde(rename = "contour")]
176    Contour,
177    #[serde(rename = "heatmap")]
178    HeatMap,
179    #[serde(rename = "histogram")]
180    Histogram,
181    #[serde(rename = "histogram2dcontour")]
182    Histogram2dContour,
183    #[serde(rename = "ohlc")]
184    Ohlc,
185    #[serde(rename = "surface")]
186    Surface,
187}
188
189impl Default for PlotType {
190    fn default() -> Self {
191        PlotType::Scatter
192    }
193}
194
195#[derive(Serialize, Clone, Debug)]
196pub enum Mode {
197    #[serde(rename = "lines")]
198    Lines,
199    #[serde(rename = "markers")]
200    Markers,
201    #[serde(rename = "text")]
202    Text,
203    #[serde(rename = "lines+markers")]
204    LinesMarkers,
205    #[serde(rename = "lines+text")]
206    LinesText,
207    #[serde(rename = "markers+text")]
208    MarkersText,
209    #[serde(rename = "lines+markers+text")]
210    LinesMarkersText,
211    #[serde(rename = "none")]
212    None,
213}
214
215#[derive(Serialize, Clone, Debug)]
216pub enum Position {
217    #[serde(rename = "top left")]
218    TopLeft,
219    #[serde(rename = "top center")]
220    TopCenter,
221    #[serde(rename = "top right")]
222    TopRight,
223    #[serde(rename = "middle left")]
224    MiddleLeft,
225    #[serde(rename = "middle center")]
226    MiddleCenter,
227    #[serde(rename = "middle right")]
228    MiddleRight,
229    #[serde(rename = "bottom left")]
230    BottomLeft,
231    #[serde(rename = "bottom center")]
232    BottomCenter,
233    #[serde(rename = "bottom right")]
234    BottomRight,
235}
236
237#[derive(Serialize, Clone, Debug)]
238pub enum MarkerSymbol {
239    #[serde(rename = "circle")]
240    Circle,
241    #[serde(rename = "circle-open")]
242    CirleOpen,
243    #[serde(rename = "circle-dot")]
244    CircleDot,
245    #[serde(rename = "circle-open-dot")]
246    CircleOpenDot,
247    #[serde(rename = "square")]
248    Square,
249    #[serde(rename = "square-open")]
250    SquareOpen,
251    #[serde(rename = "square-dot")]
252    SquareDot,
253    #[serde(rename = "square-open-dot")]
254    SquareOpenDot,
255    #[serde(rename = "diamond")]
256    Diamond,
257    #[serde(rename = "diamond-open")]
258    DiamondOpen,
259    #[serde(rename = "diamond-dot")]
260    DiamondDot,
261    #[serde(rename = "diamond-open-dot")]
262    DiamondOpenDot,
263    #[serde(rename = "cross")]
264    Cross,
265    #[serde(rename = "cross-open")]
266    CrossOpen,
267    #[serde(rename = "cross-dot")]
268    CrossDot,
269    #[serde(rename = "cross-open-dot")]
270    CrossOpenDot,
271    #[serde(rename = "x")]
272    X,
273    #[serde(rename = "x-open")]
274    XOpen,
275    #[serde(rename = "x-dot")]
276    XDot,
277    #[serde(rename = "x-open-dot")]
278    XOpenDot,
279    #[serde(rename = "triangle-up")]
280    TriangleUp,
281    #[serde(rename = "triangle-up-open")]
282    TriangleUpOpen,
283    #[serde(rename = "triangle-up-dot")]
284    TriangleUpDot,
285    #[serde(rename = "triangle-up-open-dot")]
286    TriangleUpOpenDot,
287    #[serde(rename = "triangle-down")]
288    TriangleDown,
289    #[serde(rename = "triangle-down-open")]
290    TriangleDownOpen,
291    #[serde(rename = "triangle-down-dot")]
292    TriangleDownDot,
293    #[serde(rename = "triangle-down-open-dot")]
294    TriangleDownOpenDot,
295    #[serde(rename = "triangle-left")]
296    TriangleLeft,
297    #[serde(rename = "triangle-left-open")]
298    TriangleLeftOpen,
299    #[serde(rename = "triangle-left-dot")]
300    TriangleLeftDot,
301    #[serde(rename = "triangle-left-open-dot")]
302    TriangleLeftOpenDot,
303    #[serde(rename = "triangle-right")]
304    TriangleRight,
305    #[serde(rename = "triangle-right-open")]
306    TriangleRightOpen,
307    #[serde(rename = "triangle-right-dot")]
308    TriangleRightDot,
309    #[serde(rename = "triangle-right-open-dot")]
310    TriangleRightOpenDot,
311    #[serde(rename = "triangle-ne")]
312    TriangleNE,
313    #[serde(rename = "triangle-ne-open")]
314    TriangleNEOpen,
315    #[serde(rename = "triangle-ne-dot")]
316    TriangleNEDot,
317    #[serde(rename = "triangle-ne-open-dot")]
318    TriangleNEOpenDot,
319    #[serde(rename = "triangle-se")]
320    TriangleSE,
321    #[serde(rename = "triangle-se-open")]
322    TriangleSEOpen,
323    #[serde(rename = "triangle-se-dot")]
324    TriangleSEDot,
325    #[serde(rename = "triangle-se-open-dot")]
326    TriangleSEOpenDot,
327    #[serde(rename = "triangle-sw")]
328    TriangleSW,
329    #[serde(rename = "triangle-sw-open")]
330    TriangleSWOpen,
331    #[serde(rename = "triangle-sw-dot")]
332    TriangleSWDot,
333    #[serde(rename = "triangle-sw-open-dot")]
334    TriangleSWOpenDot,
335    #[serde(rename = "triangle-nw")]
336    TriangleNW,
337    #[serde(rename = "triangle-nw-open")]
338    TriangleNWOpen,
339    #[serde(rename = "triangle-nw-dot")]
340    TriangleNWDot,
341    #[serde(rename = "triangle-nw-open-dot")]
342    TriangleNWOpenDot,
343    #[serde(rename = "pentagon")]
344    Pentagon,
345    #[serde(rename = "pentagon-open")]
346    PentagonOpen,
347    #[serde(rename = "pentagon-dot")]
348    PentagonDot,
349    #[serde(rename = "pentagon-open-dot")]
350    PentagonOpenDot,
351    #[serde(rename = "hexagon")]
352    Hexagon,
353    #[serde(rename = "hexagon-open")]
354    HexagonOpen,
355    #[serde(rename = "hexagon-dot")]
356    HexagonDot,
357    #[serde(rename = "hexagon-open-dot")]
358    HexagonOpenDot,
359    #[serde(rename = "hexagon2")]
360    Hexagon2,
361    #[serde(rename = "hexagon2-open")]
362    Hexagon2Open,
363    #[serde(rename = "hexagon2-dot")]
364    Hexagon2Dot,
365    #[serde(rename = "hexagon2-open-dot")]
366    Hexagon2OpenDot,
367    #[serde(rename = "octagon")]
368    Octagon,
369    #[serde(rename = "octagon-open")]
370    OctagonOpen,
371    #[serde(rename = "octagon-dot")]
372    OctagonDot,
373    #[serde(rename = "octagon-open-dot")]
374    OctagonOpenDot,
375    #[serde(rename = "star")]
376    Star,
377    #[serde(rename = "star-open")]
378    StarOpen,
379    #[serde(rename = "star-dot")]
380    StarDot,
381    #[serde(rename = "star-open-dot")]
382    StarOpenDot,
383    #[serde(rename = "hexagram")]
384    Hexagram,
385    #[serde(rename = "hexagram-open")]
386    HexagramOpen,
387    #[serde(rename = "hexagram-dot")]
388    HexagramDot,
389    #[serde(rename = "hexagram-open-dot")]
390    HexagramOpenDot,
391    #[serde(rename = "star-triangle-up")]
392    StarTriangleUp,
393    #[serde(rename = "star-triangle-up-open")]
394    StarTriangleUpOpen,
395    #[serde(rename = "star-triangle-up-dot")]
396    StarTriangleUpDot,
397    #[serde(rename = "star-triangle-up-open-dot")]
398    StarTriangleUpOpenDot,
399    #[serde(rename = "star-triangle-down")]
400    StarTriangleDown,
401    #[serde(rename = "star-triangle-down-open")]
402    StarTriangleDownOpen,
403    #[serde(rename = "star-triangle-down-dot")]
404    StarTriangleDownDot,
405    #[serde(rename = "star-triangle-down-open-dot")]
406    StarTriangleDownOpenDot,
407    #[serde(rename = "star-square")]
408    StarSquare,
409    #[serde(rename = "star-square-open")]
410    StarSquareOpen,
411    #[serde(rename = "star-square-dot")]
412    StarSquareDot,
413    #[serde(rename = "star-square-open-dot")]
414    StarSquareOpenDot,
415    #[serde(rename = "star-diamond")]
416    StarDiamond,
417    #[serde(rename = "star-diamond-open")]
418    StarDiamondOpen,
419    #[serde(rename = "star-diamond-dot")]
420    StarDiamondDot,
421    #[serde(rename = "star-diamond-open-dot")]
422    StarDiamondOpenDot,
423    #[serde(rename = "diamond-tall")]
424    DiamondTall,
425    #[serde(rename = "diamond-tall-open")]
426    DiamondTallOpen,
427    #[serde(rename = "diamond-tall-dot")]
428    DiamondTallDot,
429    #[serde(rename = "diamond-tall-open-dot")]
430    DiamondTallOpenDot,
431    #[serde(rename = "diamond-wide")]
432    DiamondWide,
433    #[serde(rename = "diamond-wide-open")]
434    DiamondWideOpen,
435    #[serde(rename = "diamond-wide-dot")]
436    DiamondWideDot,
437    #[serde(rename = "diamond-wide-open-dot")]
438    DiamondWideOpenDot,
439    #[serde(rename = "hourglass")]
440    Hourglass,
441    #[serde(rename = "hourglass-open")]
442    HourglassOpen,
443    #[serde(rename = "bowtie")]
444    BowTie,
445    #[serde(rename = "bowtie-open")]
446    BowTieOpen,
447    #[serde(rename = "circle-cross")]
448    CircleCross,
449    #[serde(rename = "circle-cross-open")]
450    CircleCrossOpen,
451    #[serde(rename = "circle-x")]
452    CircleX,
453    #[serde(rename = "circle-x-open")]
454    CircleXOpen,
455    #[serde(rename = "square-cross")]
456    SquareCross,
457    #[serde(rename = "square-cross-open")]
458    SquareCrossOpen,
459    #[serde(rename = "square-x")]
460    SquareX,
461    #[serde(rename = "square-x-open")]
462    SquareXOpen,
463    #[serde(rename = "diamond-cross")]
464    DiamondCross,
465    #[serde(rename = "diamond-cross-open")]
466    DiamondCrossOpen,
467    #[serde(rename = "diamond-x")]
468    DiamondX,
469    #[serde(rename = "diamond-x-open")]
470    DiamondXOpen,
471    #[serde(rename = "cross-thin")]
472    CrossThin,
473    #[serde(rename = "cross-thin-open")]
474    CrossThinOpen,
475    #[serde(rename = "x-thin")]
476    XThin,
477    #[serde(rename = "x-thin-open")]
478    XThinOpen,
479    #[serde(rename = "asterisk")]
480    Asterisk,
481    #[serde(rename = "asterisk-open")]
482    AsteriskOpen,
483    #[serde(rename = "hash")]
484    Hash,
485    #[serde(rename = "hash-open")]
486    HashOpen,
487    #[serde(rename = "hash-dot")]
488    HashDot,
489    #[serde(rename = "hash-open-dot")]
490    HashOpenDot,
491    #[serde(rename = "y-up")]
492    YUp,
493    #[serde(rename = "y-up-open")]
494    YUpOpen,
495    #[serde(rename = "y-down")]
496    YDown,
497    #[serde(rename = "y-down-open")]
498    YDownOpen,
499    #[serde(rename = "y-left")]
500    YLeft,
501    #[serde(rename = "y-left-open")]
502    YLeftOpen,
503    #[serde(rename = "y-right")]
504    YRight,
505    #[serde(rename = "y-right-open")]
506    YRightOpen,
507    #[serde(rename = "line-ew")]
508    LineEW,
509    #[serde(rename = "line-ew-open")]
510    LineEWOpen,
511    #[serde(rename = "line-ns")]
512    LineNS,
513    #[serde(rename = "line-ns-open")]
514    LineNSOpen,
515    #[serde(rename = "line-ne")]
516    LineNE,
517    #[serde(rename = "line-ne-open")]
518    LineNEOpen,
519    #[serde(rename = "line-nw")]
520    LineNW,
521    #[serde(rename = "line-nw-open")]
522    LineNWOpen,
523}
524
525#[derive(Serialize, Clone, Debug)]
526pub enum TickMode {
527    #[serde(rename = "auto")]
528    Auto,
529    #[serde(rename = "linear")]
530    Linear,
531    #[serde(rename = "array")]
532    Array,
533}
534
535#[derive(Serialize, Clone, Debug)]
536pub enum DashType {
537    #[serde(rename = "solid")]
538    Solid,
539    #[serde(rename = "dot")]
540    Dot,
541    #[serde(rename = "dash")]
542    Dash,
543    #[serde(rename = "longdashdot")]
544    LongDash,
545    #[serde(rename = "dashdot")]
546    DashDot,
547    #[serde(rename = "longdashdot")]
548    LongDashDot,
549}
550
551#[derive(Serialize, Clone, Debug)]
552pub struct ColorScaleElement(f64, String);
553
554#[derive(Serialize, Clone, Debug)]
555pub enum ColorScalePalette {
556    Greys,
557    YlGnBu,
558    Greens,
559    YlOrRd,
560    Bluered,
561    RdBu,
562    Reds,
563    Blues,
564    Picnic,
565    Rainbow,
566    Portland,
567    Jet,
568    Hot,
569    Blackbody,
570    Earth,
571    Electric,
572    Viridis,
573    Cividis,
574}
575
576#[derive(Serialize, Clone, Debug)]
577#[serde(untagged)]
578pub enum ColorScale {
579    Palette(ColorScalePalette),
580    Vector(Vec<ColorScaleElement>),
581}
582
583#[derive(Serialize, Clone, Debug)]
584pub enum LineShape {
585    #[serde(rename = "linear")]
586    Linear,
587    #[serde(rename = "spline")]
588    Spline,
589    #[serde(rename = "hv")]
590    Hv,
591    #[serde(rename = "vh")]
592    Vh,
593    #[serde(rename = "hvh")]
594    Hvh,
595    #[serde(rename = "vhv")]
596    Vhv,
597}
598
599#[derive(Serialize, Clone, Debug, Default)]
600pub struct Line {
601    #[serde(skip_serializing_if = "Option::is_none")]
602    width: Option<f64>,
603    #[serde(skip_serializing_if = "Option::is_none")]
604    shape: Option<LineShape>,
605    #[serde(skip_serializing_if = "Option::is_none")]
606    smoothing: Option<f64>,
607    #[serde(skip_serializing_if = "Option::is_none")]
608    dash: Option<DashType>,
609    #[serde(skip_serializing_if = "Option::is_none")]
610    simplify: Option<bool>,
611    #[serde(skip_serializing_if = "Option::is_none")]
612    color: Option<ColorWrapper>,
613    #[serde(skip_serializing_if = "Option::is_none")]
614    cauto: Option<bool>,
615    #[serde(skip_serializing_if = "Option::is_none")]
616    cmin: Option<f64>,
617    #[serde(skip_serializing_if = "Option::is_none")]
618    cmax: Option<f64>,
619    #[serde(skip_serializing_if = "Option::is_none")]
620    cmid: Option<f64>,
621    #[serde(skip_serializing_if = "Option::is_none", rename = "colorscale")]
622    color_scale: Option<ColorScale>,
623    #[serde(skip_serializing_if = "Option::is_none", rename = "autocolorscale")]
624    auto_color_scale: Option<bool>,
625    #[serde(skip_serializing_if = "Option::is_none", rename = "reversescale")]
626    reverse_scale: Option<bool>,
627    #[serde(skip_serializing_if = "Option::is_none", rename = "outliercolor")]
628    outlier_color: Option<ColorWrapper>,
629    #[serde(skip_serializing_if = "Option::is_none", rename = "outlierwidth")]
630    outlier_width: Option<usize>,
631}
632
633impl Line {
634    pub fn new() -> Line {
635        Default::default()
636    }
637
638    pub fn width(mut self, width: f64) -> Line {
639        self.width = Some(width);
640        self
641    }
642
643    pub fn shape(mut self, shape: LineShape) -> Line {
644        self.shape = Some(shape);
645        self
646    }
647
648    pub fn smoothing(mut self, smoothing: f64) -> Line {
649        self.smoothing = Some(smoothing);
650        self
651    }
652
653    pub fn dash(mut self, dash: DashType) -> Line {
654        self.dash = Some(dash);
655        self
656    }
657
658    pub fn simplify(mut self, simplify: bool) -> Line {
659        self.simplify = Some(simplify);
660        self
661    }
662
663    pub fn color<C: Color>(mut self, color: C) -> Line {
664        self.color = Some(color.to_color());
665        self
666    }
667
668    pub fn cauto(mut self, cauto: bool) -> Line {
669        self.cauto = Some(cauto);
670        self
671    }
672
673    pub fn cmin(mut self, cmin: f64) -> Line {
674        self.cmin = Some(cmin);
675        self
676    }
677
678    pub fn cmax(mut self, cmax: f64) -> Line {
679        self.cmax = Some(cmax);
680        self
681    }
682
683    pub fn cmid(mut self, cmid: f64) -> Line {
684        self.cmid = Some(cmid);
685        self
686    }
687
688    pub fn color_scale(mut self, color_scale: ColorScale) -> Line {
689        self.color_scale = Some(color_scale);
690        self
691    }
692
693    pub fn auto_color_scale(mut self, auto_color_scale: bool) -> Line {
694        self.auto_color_scale = Some(auto_color_scale);
695        self
696    }
697
698    pub fn reverse_scale(mut self, reverse_scale: bool) -> Line {
699        self.reverse_scale = Some(reverse_scale);
700        self
701    }
702
703    pub fn outlier_color<C: Color>(mut self, outlier_color: C) -> Line {
704        self.outlier_color = Some(outlier_color.to_color());
705        self
706    }
707
708    pub fn outlier_width(mut self, outlier_width: usize) -> Line {
709        self.outlier_width = Some(outlier_width);
710        self
711    }
712}
713
714#[derive(Serialize, Clone, Debug)]
715pub enum GradientType {
716    #[serde(rename = "radial")]
717    Radial,
718    #[serde(rename = "horizontal")]
719    Horizontal,
720    #[serde(rename = "vertical")]
721    Vertical,
722    #[serde(rename = "none")]
723    None,
724}
725
726#[derive(Serialize, Clone, Debug)]
727pub enum SizeMode {
728    #[serde(rename = "diameter")]
729    Diameter,
730    #[serde(rename = "area")]
731    Area,
732}
733
734#[derive(Serialize, Clone, Debug)]
735pub enum ThicknessMode {
736    #[serde(rename = "fraction")]
737    Fraction,
738    #[serde(rename = "pixels")]
739    Pixels,
740}
741
742#[derive(Serialize, Clone, Debug)]
743pub enum Anchor {
744    #[serde(rename = "auto")]
745    Auto,
746    #[serde(rename = "left")]
747    Left,
748    #[serde(rename = "center")]
749    Center,
750    #[serde(rename = "right")]
751    Right,
752    #[serde(rename = "top")]
753    Top,
754    #[serde(rename = "middle")]
755    Middle,
756    #[serde(rename = "bottom")]
757    Bottom,
758}
759
760#[derive(Serialize, Clone, Debug)]
761pub enum TextAnchor {
762    #[serde(rename = "start")]
763    Start,
764    #[serde(rename = "middle")]
765    Middle,
766    #[serde(rename = "end")]
767    End,
768}
769
770#[derive(Serialize, Clone, Debug)]
771pub enum ExponentFormat {
772    #[serde(rename = "none")]
773    None,
774    #[serde(rename = "e")]
775    SmallE,
776    #[serde(rename = "E")]
777    CapitalE,
778    #[serde(rename = "power")]
779    Power,
780    #[serde(rename = "SI")]
781    SI,
782    #[serde(rename = "B")]
783    B,
784}
785
786#[derive(Serialize, Clone, Debug)]
787pub struct Gradient {
788    r#type: GradientType,
789    color: Dim<ColorWrapper>,
790}
791
792impl Gradient {
793    pub fn new<C: Color + Serialize>(gradient_type: GradientType, color: Dim<C>) -> Gradient {
794        let color = match color {
795            Dim::Scalar(c) => Dim::Scalar(c.to_color()),
796            Dim::Vector(c) => Dim::Vector(private::to_color_array(c)),
797        };
798        Gradient {
799            r#type: gradient_type,
800            color,
801        }
802    }
803}
804
805#[derive(Serialize, Clone, Debug, Default)]
806pub struct TickFormatStop {
807    enabled: bool,
808    #[serde(skip_serializing_if = "Option::is_none", rename = "dtickrange")]
809    dtick_range: Option<Vec<NumOrStringWrapper>>,
810    #[serde(skip_serializing_if = "Option::is_none")]
811    value: Option<String>,
812    #[serde(skip_serializing_if = "Option::is_none")]
813    name: Option<String>,
814    #[serde(skip_serializing_if = "Option::is_none", rename = "templateitemname")]
815    template_item_name: Option<String>,
816}
817
818impl TickFormatStop {
819    pub fn new() -> TickFormatStop {
820        TickFormatStop {
821            enabled: true,
822            ..Default::default()
823        }
824    }
825
826    pub fn enabled(mut self, enabled: bool) -> TickFormatStop {
827        self.enabled = enabled;
828        self
829    }
830
831    pub fn dtick_range<C: NumOrString>(mut self, range: Vec<C>) -> TickFormatStop {
832        let wrapped = to_num_or_string_wrapper(range);
833        self.dtick_range = Some(wrapped);
834        self
835    }
836
837    pub fn value(mut self, value: &str) -> TickFormatStop {
838        self.value = Some(value.to_owned());
839        self
840    }
841
842    pub fn name(mut self, name: &str) -> TickFormatStop {
843        self.name = Some(name.to_owned());
844        self
845    }
846
847    pub fn template_item_name(mut self, name: &str) -> TickFormatStop {
848        self.template_item_name = Some(name.to_owned());
849        self
850    }
851}
852
853#[derive(Serialize, Clone, Debug)]
854pub struct ColorBar {
855    #[serde(skip_serializing_if = "Option::is_none", rename = "thicknessmode")]
856    thickness_mode: Option<ThicknessMode>,
857    thickness: usize,
858    #[serde(skip_serializing_if = "Option::is_none", rename = "lenmode")]
859    len_mode: Option<ThicknessMode>,
860    len: usize,
861    x: f64,
862    #[serde(rename = "xanchor")]
863    x_anchor: Anchor,
864    #[serde(rename = "xpad")]
865    x_pad: f64,
866    y: f64,
867    #[serde(rename = "yanchor")]
868    y_anchor: Anchor,
869    #[serde(rename = "ypad")]
870    y_pad: f64,
871    #[serde(skip_serializing_if = "Option::is_none", rename = "outlinecolor")]
872    outline_color: Option<ColorWrapper>,
873    #[serde(rename = "outlinewidth")]
874    outline_width: usize,
875    #[serde(skip_serializing_if = "Option::is_none", rename = "bordercolor")]
876    border_color: Option<ColorWrapper>,
877    #[serde(rename = "borderwidth")]
878    border_width: usize,
879    #[serde(skip_serializing_if = "Option::is_none", rename = "bgcolor")]
880    background_color: Option<ColorWrapper>,
881    #[serde(skip_serializing_if = "Option::is_none", rename = "tickmode")]
882    tick_mode: Option<TickMode>,
883    #[serde(rename = "nticks")]
884    n_ticks: usize,
885    #[serde(skip_serializing_if = "Option::is_none")]
886    tick0: Option<f64>,
887    #[serde(skip_serializing_if = "Option::is_none")]
888    dtick: Option<f64>,
889    #[serde(skip_serializing_if = "Option::is_none", rename = "tickvals")]
890    tick_vals: Option<Vec<f64>>,
891    #[serde(skip_serializing_if = "Option::is_none", rename = "ticktext")]
892    tick_text: Option<Vec<String>>,
893    #[serde(skip_serializing_if = "Option::is_none")]
894    ticks: Option<String>,
895    #[serde(rename = "ticklen")]
896    tick_len: usize,
897    #[serde(rename = "tickwidth")]
898    tick_width: usize,
899    #[serde(skip_serializing_if = "Option::is_none", rename = "tickcolor")]
900    tick_color: Option<ColorWrapper>,
901    #[serde(rename = "showticklabels")]
902    show_tick_labels: bool,
903    #[serde(skip_serializing_if = "Option::is_none", rename = "tickfont")]
904    tick_font: Option<Font>,
905    #[serde(skip_serializing_if = "Option::is_none", rename = "tickangle")]
906    tick_angle: Option<f64>,
907    #[serde(skip_serializing_if = "Option::is_none", rename = "tickformat")]
908    tick_format: Option<String>,
909    #[serde(skip_serializing_if = "Option::is_none", rename = "tickformatstops")]
910    tick_format_stops: Option<Vec<TickFormatStop>>,
911    #[serde(skip_serializing_if = "Option::is_none", rename = "tickprefix")]
912    tick_prefix: Option<String>,
913    #[serde(skip_serializing_if = "Option::is_none", rename = "showtickprefix")]
914    show_tick_prefix: Option<String>,
915    #[serde(skip_serializing_if = "Option::is_none", rename = "ticksuffix")]
916    tick_suffix: Option<String>,
917    #[serde(skip_serializing_if = "Option::is_none", rename = "showticksuffix")]
918    show_tick_suffix: Option<String>,
919    separate_thousands: bool,
920    #[serde(skip_serializing_if = "Option::is_none", rename = "exponentformat")]
921    exponent_format: Option<ExponentFormat>,
922    #[serde(skip_serializing_if = "Option::is_none", rename = "showexponent")]
923    show_exponent: Option<String>,
924    #[serde(skip_serializing_if = "Option::is_none")]
925    title: Option<Title>,
926}
927
928impl Default for ColorBar {
929    fn default() -> Self {
930        Self::new()
931    }
932}
933
934impl ColorBar {
935    pub fn new() -> ColorBar {
936        ColorBar {
937            thickness: 30,
938            len: 1,
939            x: 1.02,
940            x_anchor: Anchor::Left,
941            x_pad: 10.0,
942            y: 0.5,
943            y_anchor: Anchor::Middle,
944            y_pad: 10.0,
945            outline_width: 1,
946            border_width: 0,
947            n_ticks: 0,
948            tick_len: 5,
949            tick_width: 1,
950            show_tick_labels: true,
951            separate_thousands: true,
952            ..Default::default()
953        }
954    }
955
956    pub fn thickness_mode(mut self, thickness_mode: ThicknessMode) -> ColorBar {
957        self.thickness_mode = Some(thickness_mode);
958        self
959    }
960
961    pub fn thickness(mut self, thickness: usize) -> ColorBar {
962        self.thickness = thickness;
963        self
964    }
965
966    pub fn len_mode(mut self, len_mode: ThicknessMode) -> ColorBar {
967        self.len_mode = Some(len_mode);
968        self
969    }
970
971    pub fn len(mut self, len: usize) -> ColorBar {
972        self.len = len;
973        self
974    }
975
976    pub fn x(mut self, x: f64) -> ColorBar {
977        self.x = x;
978        self
979    }
980
981    pub fn x_anchor(mut self, x_anchor: Anchor) -> ColorBar {
982        self.x_anchor = x_anchor;
983        self
984    }
985
986    pub fn x_pad(mut self, x_pad: f64) -> ColorBar {
987        self.x_pad = x_pad;
988        self
989    }
990
991    pub fn y(mut self, y: f64) -> ColorBar {
992        self.y = y;
993        self
994    }
995
996    pub fn y_anchor(mut self, y_anchor: Anchor) -> ColorBar {
997        self.y_anchor = y_anchor;
998        self
999    }
1000
1001    pub fn y_pad(mut self, y_pad: f64) -> ColorBar {
1002        self.y_pad = y_pad;
1003        self
1004    }
1005
1006    pub fn outline_color<C: Color>(mut self, outline_color: C) -> ColorBar {
1007        self.outline_color = Some(outline_color.to_color());
1008        self
1009    }
1010
1011    pub fn outline_width(mut self, outline_width: usize) -> ColorBar {
1012        self.outline_width = outline_width;
1013        self
1014    }
1015
1016    pub fn border_color<C: Color>(mut self, border_color: C) -> ColorBar {
1017        self.border_color = Some(border_color.to_color());
1018        self
1019    }
1020
1021    pub fn border_width(mut self, border_width: usize) -> ColorBar {
1022        self.border_width = border_width;
1023        self
1024    }
1025
1026    pub fn background_color<C: Color>(mut self, background_color: C) -> ColorBar {
1027        self.background_color = Some(background_color.to_color());
1028        self
1029    }
1030
1031    pub fn tick_mode(mut self, tick_mode: TickMode) -> ColorBar {
1032        self.tick_mode = Some(tick_mode);
1033        self
1034    }
1035
1036    pub fn n_ticks(mut self, n_ticks: usize) -> ColorBar {
1037        self.n_ticks = n_ticks;
1038        self
1039    }
1040
1041    pub fn tick0(mut self, tick0: f64) -> ColorBar {
1042        self.tick0 = Some(tick0);
1043        self
1044    }
1045
1046    pub fn dtick(mut self, dtick: f64) -> ColorBar {
1047        self.dtick = Some(dtick);
1048        self
1049    }
1050
1051    pub fn tick_vals(mut self, tick_vals: Vec<f64>) -> ColorBar {
1052        self.tick_vals = Some(tick_vals);
1053        self
1054    }
1055
1056    pub fn tick_text(mut self, tick_text: Vec<String>) -> ColorBar {
1057        self.tick_text = Some(tick_text);
1058        self
1059    }
1060
1061    pub fn ticks(mut self, ticks: &str) -> ColorBar {
1062        self.ticks = Some(ticks.to_owned());
1063        self
1064    }
1065
1066    pub fn tick_len(mut self, tick_len: usize) -> ColorBar {
1067        self.tick_len = tick_len;
1068        self
1069    }
1070
1071    pub fn tick_width(mut self, tick_width: usize) -> ColorBar {
1072        self.tick_width = tick_width;
1073        self
1074    }
1075
1076    pub fn tick_color<C: Color>(mut self, tick_color: C) -> ColorBar {
1077        self.tick_color = Some(tick_color.to_color());
1078        self
1079    }
1080
1081    pub fn show_tick_labels(mut self, show_tick_labels: bool) -> ColorBar {
1082        self.show_tick_labels = show_tick_labels;
1083        self
1084    }
1085
1086    pub fn tick_font(mut self, tick_font: Font) -> ColorBar {
1087        self.tick_font = Some(tick_font);
1088        self
1089    }
1090
1091    pub fn tick_angle(mut self, tick_angle: f64) -> ColorBar {
1092        self.tick_angle = Some(tick_angle);
1093        self
1094    }
1095
1096    pub fn tick_format(mut self, tick_format: &str) -> ColorBar {
1097        self.tick_format = Some(tick_format.to_owned());
1098        self
1099    }
1100
1101    pub fn tick_format_stops(mut self, tick_format_stops: Vec<TickFormatStop>) -> ColorBar {
1102        self.tick_format_stops = Some(tick_format_stops);
1103        self
1104    }
1105
1106    pub fn tick_prefix(mut self, tick_prefix: &str) -> ColorBar {
1107        self.tick_prefix = Some(tick_prefix.to_owned());
1108        self
1109    }
1110
1111    pub fn show_tick_prefix(mut self, show_tick_prefix: &str) -> ColorBar {
1112        self.show_tick_prefix = Some(show_tick_prefix.to_owned());
1113        self
1114    }
1115
1116    pub fn tick_suffix(mut self, tick_suffix: &str) -> ColorBar {
1117        self.tick_suffix = Some(tick_suffix.to_owned());
1118        self
1119    }
1120
1121    pub fn show_tick_suffix(mut self, show_tick_suffix: &str) -> ColorBar {
1122        self.show_tick_suffix = Some(show_tick_suffix.to_owned());
1123        self
1124    }
1125
1126    pub fn separate_thousands(mut self, separate_thousands: bool) -> ColorBar {
1127        self.separate_thousands = separate_thousands;
1128        self
1129    }
1130
1131    pub fn exponent_format(mut self, exponent_format: ExponentFormat) -> ColorBar {
1132        self.exponent_format = Some(exponent_format);
1133        self
1134    }
1135
1136    pub fn show_exponent(mut self, show_exponent: &str) -> ColorBar {
1137        self.show_exponent = Some(show_exponent.to_owned());
1138        self
1139    }
1140
1141    pub fn title(mut self, title: Title) -> ColorBar {
1142        self.title = Some(title);
1143        self
1144    }
1145}
1146
1147#[derive(Serialize, Clone, Debug, Default)]
1148pub struct Marker {
1149    #[serde(skip_serializing_if = "Option::is_none")]
1150    symbol: Option<MarkerSymbol>,
1151    #[serde(skip_serializing_if = "Option::is_none")]
1152    opacity: Option<f64>,
1153    #[serde(skip_serializing_if = "Option::is_none")]
1154    size: Option<Dim<usize>>,
1155    #[serde(skip_serializing_if = "Option::is_none", rename = "maxdisplayed")]
1156    max_displayed: Option<usize>,
1157    #[serde(skip_serializing_if = "Option::is_none", rename = "sizeref")]
1158    size_ref: Option<usize>,
1159    #[serde(skip_serializing_if = "Option::is_none", rename = "sizemin")]
1160    size_min: Option<usize>,
1161    #[serde(skip_serializing_if = "Option::is_none", rename = "sizemin")]
1162    size_mode: Option<SizeMode>,
1163    #[serde(skip_serializing_if = "Option::is_none")]
1164    line: Option<Line>,
1165    #[serde(skip_serializing_if = "Option::is_none")]
1166    gradient: Option<Gradient>,
1167    #[serde(skip_serializing_if = "Option::is_none")]
1168    color: Option<Dim<ColorWrapper>>,
1169    #[serde(skip_serializing_if = "Option::is_none")]
1170    cauto: Option<bool>,
1171    #[serde(skip_serializing_if = "Option::is_none")]
1172    cmin: Option<f64>,
1173    #[serde(skip_serializing_if = "Option::is_none")]
1174    cmax: Option<f64>,
1175    #[serde(skip_serializing_if = "Option::is_none")]
1176    cmid: Option<f64>,
1177    #[serde(skip_serializing_if = "Option::is_none", rename = "colorscale")]
1178    color_scale: Option<ColorScale>,
1179    #[serde(skip_serializing_if = "Option::is_none", rename = "autocolorscale")]
1180    auto_color_scale: Option<bool>,
1181    #[serde(skip_serializing_if = "Option::is_none", rename = "reversescale")]
1182    reverse_scale: Option<bool>,
1183    #[serde(skip_serializing_if = "Option::is_none", rename = "showscale")]
1184    show_scale: Option<bool>,
1185    #[serde(skip_serializing_if = "Option::is_none", rename = "colorbar")]
1186    color_bar: Option<ColorBar>,
1187    #[serde(skip_serializing_if = "Option::is_none", rename = "outliercolor")]
1188    outlier_color: Option<ColorWrapper>,
1189}
1190
1191impl Marker {
1192    pub fn new() -> Marker {
1193        Default::default()
1194    }
1195
1196    pub fn symbol(mut self, symbol: MarkerSymbol) -> Marker {
1197        self.symbol = Some(symbol);
1198        self
1199    }
1200
1201    pub fn opacity(mut self, opacity: f64) -> Marker {
1202        self.opacity = Some(opacity);
1203        self
1204    }
1205
1206    pub fn size(mut self, size: usize) -> Marker {
1207        self.size = Some(Dim::Scalar(size));
1208        self
1209    }
1210
1211    pub fn size_array(mut self, size: Vec<usize>) -> Marker {
1212        self.size = Some(Dim::Vector(size));
1213        self
1214    }
1215
1216    pub fn max_displayed(mut self, size: usize) -> Marker {
1217        self.max_displayed = Some(size);
1218        self
1219    }
1220
1221    pub fn size_ref(mut self, size: usize) -> Marker {
1222        self.size_ref = Some(size);
1223        self
1224    }
1225
1226    pub fn size_min(mut self, size: usize) -> Marker {
1227        self.size_min = Some(size);
1228        self
1229    }
1230
1231    pub fn size_mode(mut self, mode: SizeMode) -> Marker {
1232        self.size_mode = Some(mode);
1233        self
1234    }
1235
1236    pub fn line(mut self, line: Line) -> Marker {
1237        self.line = Some(line);
1238        self
1239    }
1240
1241    pub fn gradient(mut self, gradient: Gradient) -> Marker {
1242        self.gradient = Some(gradient);
1243        self
1244    }
1245
1246    pub fn color<C: Color>(mut self, color: C) -> Marker {
1247        self.color = Some(Dim::Scalar(color.to_color()));
1248        self
1249    }
1250
1251    pub fn color_array<C: Color>(mut self, color: Vec<C>) -> Marker {
1252        let color = private::to_color_array(color);
1253        self.color = Some(Dim::Vector(color));
1254        self
1255    }
1256
1257    pub fn cauto(mut self, cauto: bool) -> Marker {
1258        self.cauto = Some(cauto);
1259        self
1260    }
1261
1262    pub fn cmin(mut self, cmin: f64) -> Marker {
1263        self.cmin = Some(cmin);
1264        self
1265    }
1266
1267    pub fn cmax(mut self, cmax: f64) -> Marker {
1268        self.cmax = Some(cmax);
1269        self
1270    }
1271
1272    pub fn cmid(mut self, cmid: f64) -> Marker {
1273        self.cmid = Some(cmid);
1274        self
1275    }
1276
1277    pub fn color_scale(mut self, color_scale: ColorScale) -> Marker {
1278        self.color_scale = Some(color_scale);
1279        self
1280    }
1281
1282    pub fn auto_color_scale(mut self, auto_color_scale: bool) -> Marker {
1283        self.auto_color_scale = Some(auto_color_scale);
1284        self
1285    }
1286
1287    pub fn reverse_scale(mut self, reverse_scale: bool) -> Marker {
1288        self.reverse_scale = Some(reverse_scale);
1289        self
1290    }
1291
1292    pub fn show_scale(mut self, show_scale: bool) -> Marker {
1293        self.show_scale = Some(show_scale);
1294        self
1295    }
1296
1297    pub fn color_bar(mut self, colorbar: ColorBar) -> Marker {
1298        self.color_bar = Some(colorbar);
1299        self
1300    }
1301
1302    pub fn outlier_color<C: Color>(mut self, outlier_color: C) -> Marker {
1303        self.outlier_color = Some(outlier_color.to_color());
1304        self
1305    }
1306}
1307
1308#[derive(Serialize, Clone, Debug, Default)]
1309pub struct Font {
1310    #[serde(skip_serializing_if = "Option::is_none")]
1311    family: Option<String>,
1312    #[serde(skip_serializing_if = "Option::is_none")]
1313    size: Option<usize>,
1314    #[serde(skip_serializing_if = "Option::is_none")]
1315    color: Option<ColorWrapper>,
1316}
1317
1318impl Font {
1319    pub fn new() -> Font {
1320        Default::default()
1321    }
1322
1323    pub fn family(mut self, family: &str) -> Font {
1324        self.family = Some(family.to_owned());
1325        self
1326    }
1327
1328    pub fn size(mut self, size: usize) -> Font {
1329        self.size = Some(size);
1330        self
1331    }
1332
1333    pub fn color<C: Color>(mut self, color: C) -> Font {
1334        self.color = Some(color.to_color());
1335        self
1336    }
1337}
1338
1339#[derive(Serialize, Clone, Debug)]
1340pub enum Side {
1341    #[serde(rename = "right")]
1342    Right,
1343    #[serde(rename = "top")]
1344    Top,
1345    #[serde(rename = "bottom")]
1346    Bottom,
1347    #[serde(rename = "left")]
1348    Left,
1349    #[serde(rename = "top left")]
1350    TopLeft,
1351}
1352
1353#[derive(Serialize, Clone, Debug)]
1354pub enum Reference {
1355    #[serde(rename = "container")]
1356    Container,
1357    #[serde(rename = "paper")]
1358    Paper,
1359}
1360
1361#[derive(Serialize, Clone, Debug)]
1362pub struct Pad {
1363    t: usize,
1364    b: usize,
1365    l: usize,
1366}
1367
1368impl Pad {
1369    pub fn new(t: usize, b: usize, l: usize) -> Pad {
1370        Pad { t, b, l }
1371    }
1372}
1373
1374#[derive(Serialize, Clone, Debug, Default)]
1375pub struct Title {
1376    text: String,
1377    #[serde(skip_serializing_if = "Option::is_none")]
1378    font: Option<Font>,
1379    #[serde(skip_serializing_if = "Option::is_none")]
1380    side: Option<Side>,
1381    #[serde(skip_serializing_if = "Option::is_none", rename = "xref")]
1382    x_ref: Option<Reference>,
1383    #[serde(skip_serializing_if = "Option::is_none", rename = "yref")]
1384    y_ref: Option<Reference>,
1385    #[serde(skip_serializing_if = "Option::is_none")]
1386    x: Option<f64>,
1387    #[serde(skip_serializing_if = "Option::is_none")]
1388    y: Option<f64>,
1389    #[serde(skip_serializing_if = "Option::is_none", rename = "xanchor")]
1390    x_anchor: Option<Anchor>,
1391    #[serde(skip_serializing_if = "Option::is_none", rename = "yanchor")]
1392    y_anchor: Option<Anchor>,
1393    #[serde(skip_serializing_if = "Option::is_none")]
1394    pad: Option<Pad>,
1395}
1396
1397impl From<&str> for Title {
1398    fn from(title: &str) -> Self {
1399        Title::new(title)
1400    }
1401}
1402
1403impl Title {
1404    pub fn new(text: &str) -> Title {
1405        Title {
1406            text: text.to_owned(),
1407            ..Default::default()
1408        }
1409    }
1410
1411    pub fn font(mut self, font: Font) -> Title {
1412        self.font = Some(font);
1413        self
1414    }
1415
1416    pub fn side(mut self, side: Side) -> Title {
1417        self.side = Some(side);
1418        self
1419    }
1420
1421    pub fn x_ref(mut self, xref: Reference) -> Title {
1422        self.x_ref = Some(xref);
1423        self
1424    }
1425
1426    pub fn y_ref(mut self, yref: Reference) -> Title {
1427        self.y_ref = Some(yref);
1428        self
1429    }
1430
1431    pub fn x(mut self, x: f64) -> Title {
1432        self.x = Some(x);
1433        self
1434    }
1435
1436    pub fn y(mut self, y: f64) -> Title {
1437        self.y = Some(y);
1438        self
1439    }
1440
1441    pub fn x_anchor(mut self, anchor: Anchor) -> Title {
1442        self.x_anchor = Some(anchor);
1443        self
1444    }
1445
1446    pub fn y_anchor(mut self, anchor: Anchor) -> Title {
1447        self.y_anchor = Some(anchor);
1448        self
1449    }
1450
1451    pub fn pad(mut self, pad: Pad) -> Title {
1452        self.pad = Some(pad);
1453        self
1454    }
1455}
1456
1457#[derive(Serialize, Clone, Debug, Default)]
1458pub struct Label {
1459    #[serde(skip_serializing_if = "Option::is_none", rename = "bgcolor")]
1460    background_color: Option<ColorWrapper>,
1461    #[serde(skip_serializing_if = "Option::is_none", rename = "bordercolor")]
1462    border_color: Option<ColorWrapper>,
1463    #[serde(skip_serializing_if = "Option::is_none")]
1464    font: Option<Font>,
1465    #[serde(skip_serializing_if = "Option::is_none")]
1466    align: Option<String>,
1467    #[serde(skip_serializing_if = "Option::is_none", rename = "namelength")]
1468    name_length: Option<Dim<i32>>,
1469}
1470
1471impl Label {
1472    pub fn new() -> Label {
1473        Default::default()
1474    }
1475
1476    pub fn background_color<C: Color>(mut self, background_color: C) -> Label {
1477        self.background_color = Some(background_color.to_color());
1478        self
1479    }
1480
1481    pub fn border_color<C: Color>(mut self, border_color: C) -> Label {
1482        self.border_color = Some(border_color.to_color());
1483        self
1484    }
1485
1486    pub fn font(mut self, font: Font) -> Label {
1487        self.font = Some(font);
1488        self
1489    }
1490
1491    pub fn align(mut self, align: &str) -> Label {
1492        self.align = Some(align.to_owned());
1493        self
1494    }
1495
1496    pub fn name_length(mut self, name_length: i32) -> Label {
1497        self.name_length = Some(Dim::Scalar(name_length));
1498        self
1499    }
1500
1501    pub fn name_length_array(mut self, name_length: Vec<i32>) -> Label {
1502        self.name_length = Some(Dim::Vector(name_length));
1503        self
1504    }
1505}
1506
1507#[derive(Serialize, Clone, Debug)]
1508pub enum ErrorType {
1509    #[serde(rename = "percent")]
1510    Percent,
1511    #[serde(rename = "constant")]
1512    Constant,
1513    #[serde(rename = "sqrt")]
1514    SquareRoot,
1515    #[serde(rename = "data")]
1516    Data,
1517}
1518
1519impl Default for ErrorType {
1520    fn default() -> Self {
1521        ErrorType::Percent
1522    }
1523}
1524
1525#[derive(Serialize, Clone, Debug, Default)]
1526pub struct ErrorData {
1527    r#type: ErrorType,
1528    #[serde(skip_serializing_if = "Option::is_none")]
1529    array: Option<Vec<f64>>,
1530    #[serde(skip_serializing_if = "Option::is_none")]
1531    visible: Option<bool>,
1532    #[serde(skip_serializing_if = "Option::is_none")]
1533    symmetric: Option<bool>,
1534    #[serde(skip_serializing_if = "Option::is_none", rename = "arrayminus")]
1535    array_minus: Option<Vec<f64>>,
1536    #[serde(skip_serializing_if = "Option::is_none")]
1537    value: Option<f64>,
1538    #[serde(skip_serializing_if = "Option::is_none", rename = "valueminus")]
1539    value_minus: Option<f64>,
1540    #[serde(skip_serializing_if = "Option::is_none", rename = "traceref")]
1541    trace_ref: Option<usize>,
1542    #[serde(skip_serializing_if = "Option::is_none", rename = "tracerefminus")]
1543    trace_ref_minus: Option<usize>,
1544    #[serde(skip_serializing_if = "Option::is_none")]
1545    copy_ystyle: Option<bool>,
1546    #[serde(skip_serializing_if = "Option::is_none")]
1547    color: Option<ColorWrapper>,
1548    #[serde(skip_serializing_if = "Option::is_none")]
1549    thickness: Option<f64>,
1550    #[serde(skip_serializing_if = "Option::is_none")]
1551    width: Option<usize>,
1552}
1553
1554impl ErrorData {
1555    pub fn new(error_type: ErrorType) -> ErrorData {
1556        ErrorData {
1557            r#type: error_type,
1558            ..Default::default()
1559        }
1560    }
1561
1562    pub fn array(mut self, array: Vec<f64>) -> ErrorData {
1563        self.array = Some(array);
1564        self
1565    }
1566
1567    pub fn visible(mut self, visible: bool) -> ErrorData {
1568        self.visible = Some(visible);
1569        self
1570    }
1571
1572    pub fn symmetric(mut self, symmetric: bool) -> ErrorData {
1573        self.symmetric = Some(symmetric);
1574        self
1575    }
1576
1577    pub fn array_minus(mut self, array_minus: Vec<f64>) -> ErrorData {
1578        self.array_minus = Some(array_minus);
1579        self
1580    }
1581
1582    pub fn value(mut self, value: f64) -> ErrorData {
1583        self.value = Some(value);
1584        self
1585    }
1586
1587    pub fn value_minus(mut self, value_minus: f64) -> ErrorData {
1588        self.value_minus = Some(value_minus);
1589        self
1590    }
1591
1592    pub fn trace_ref(mut self, trace_ref: usize) -> ErrorData {
1593        self.trace_ref = Some(trace_ref);
1594        self
1595    }
1596
1597    pub fn trace_ref_minus(mut self, trace_ref_minus: usize) -> ErrorData {
1598        self.trace_ref_minus = Some(trace_ref_minus);
1599        self
1600    }
1601
1602    pub fn copy_ystyle(mut self, copy_ystyle: bool) -> ErrorData {
1603        self.copy_ystyle = Some(copy_ystyle);
1604        self
1605    }
1606
1607    pub fn color<C: Color>(mut self, color: C) -> ErrorData {
1608        self.color = Some(color.to_color());
1609        self
1610    }
1611
1612    pub fn thickness(mut self, thickness: f64) -> ErrorData {
1613        self.thickness = Some(thickness);
1614        self
1615    }
1616
1617    pub fn width(mut self, width: usize) -> ErrorData {
1618        self.width = Some(width);
1619        self
1620    }
1621}
plotly_patched/common/mod.rs

plotly_patched/common/
mod.rs
