Loading...
Searching...
No Matches
AlignSVG.h
1/*
2
3MIT License
4
5Copyright (c) 2023 FMI Open Development / Markus Peura, first.last@fmi.fi
6
7Permission is hereby granted, free of charge, to any person obtaining a copy
8of this software and associated documentation files (the "Software"), to deal
9in the Software without restriction, including without limitation the rights
10to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11copies of the Software, and to permit persons to whom the Software is
12furnished to do so, subject to the following conditions:
13
14The above copyright notice and this permission notice shall be included in all
15copies or substantial portions of the Software.
16
17THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23SOFTWARE.
24
25*/
26/*
27Part of Rack development has been done in the BALTRAD projects part-financed
28by the European Union (European Regional Development Fund and European
29Neighbourhood Partnership Instrument, Baltic Sea Region Programme 2007-2013)
30*/
31/*
32 * TreeSVG.h
33 *
34 * Created on: Nov, 2024
35 * Author: mpeura
36 */
37
38#ifndef DRAIN_ALIGN_SVG
39#define DRAIN_ALIGN_SVG
40
41//#include "drain/util/FileInfo.h"
42// #include "drain/util/Frame.h"
43//
44#include <string>
45#include "drain/util/EnumFlags.h"
46
47namespace drain {
48
49namespace image {
50
51
53struct AlignBase {
54
55public:
56
58 enum Pos {
59 UNDEFINED_POS = 0,
60 MIN = 1, // LEFT (if HORZ) or TOP (when VERT) 0b01010101,
61 MAX = 2, // RIGHT (if HORZ) or BOTTOM (when VERT) 0b10101010,
62 MID = 3, // 0b11111111,
63 FILL = 4,
64 // ABSOLUTE?
65 };
66
67 enum Axis {
68 // Index, must contain 0 and 1 for HORZ and VERT
69 HORZ = 0, // 0b00110011,
70 VERT = 1, // b11001100,
71 UNDEFINED_AXIS = 2,
72 };
73
74 static inline
75 Axis flip(Axis axis){
76 switch (axis){
77 case HORZ:
78 return VERT;
79 case VERT:
80 return HORZ;
81 default:
82 return UNDEFINED_AXIS;
83 }
84 };
85
86 //typedef drain::EnumDict<Coord>::dict_t pos_dict_t;
87
88 static inline
90 switch (pos){
91 case MAX:
92 return MIN;
93 case MIN:
94 return MAX;
95 case MID:
96 case FILL:
97 case UNDEFINED_POS:
98 default:
99 return pos;
100 }
101 };
102
103};
104
105
106template <>
108DRAIN_ENUM_OSTREAM(AlignBase::Axis);
109
110template <>
112DRAIN_ENUM_OSTREAM(AlignBase::Pos);
113
114
116
125template <typename AX = AlignBase::Axis, AlignBase::Axis A = AlignBase::Axis::UNDEFINED_AXIS, typename POS = AlignBase::Pos> // , Align::Coord POS = Align::Coord::UNDEFINED_POS>
126struct Alignment {
127
128 // Align::Axis
129 AX axis; // = V; // compiler error if different type?
130
131 //AlignBase::Pos pos
132 POS pos = AlignBase::Pos::UNDEFINED_POS; // or middle?
133
135 inline
136 Alignment(AlignBase::Pos pos = AlignBase::Pos::UNDEFINED_POS) : axis(A), pos(pos){
137 }
138
140 inline
141 Alignment(const Alignment & ac) : axis(ac.axis), pos(ac.pos){
142 }
143
144
145 inline
146 Alignment(AlignBase::Axis axis, AlignBase::Pos pos = AlignBase::Pos::UNDEFINED_POS): axis(axis), pos(pos){
147 }
148
149 template <typename AX2, AlignBase::Axis A2>
150 inline
151 Alignment(const Alignment<AX2,A2> & align) : pos(align.pos){ // axis(ac.axis),
152 axis = align.axis; // error if const
153 }
154
156 inline virtual
158
159
160 inline
161 const AlignBase::Axis & get(const AlignBase::Axis & defaultValue) const {
162 if (axis != AlignBase::Axis::UNDEFINED_AXIS){
163 return axis;
164 }
165 else {
166 return defaultValue;
167 }
168 }
169
170 inline
171 const AlignBase::Pos & get(const AlignBase::Pos & defaultValue) const {
172 if (pos != AlignBase::Pos::UNDEFINED_POS){
173 return pos;
174 }
175 else {
176 return defaultValue;
177 }
178 }
179
180
181 virtual inline
182 void reset(){
183 axis = AlignBase::Axis::UNDEFINED_AXIS;
184 pos = AlignBase::Pos::UNDEFINED_POS;
185 }
186
187
188 template <typename AX2, AlignBase::Axis A2>
189 inline
190 bool operator==(const Alignment<AX2,A2> & align) const {
191 return (align.axis == axis) && (align.pos == pos);
192 // return compare(ad) == 0;
193 }
194
195
196};
197
198
199
200template <typename AX, AlignBase::Axis V>
201inline
202std::ostream & operator<<(std::ostream &ostr, const Alignment<AX,V> & align){
203 //return ostr << align.axis << '_' << align.pos; // enums resolved above
204 return ostr << align.axis << '_' << align.pos;
205}
206
207
208
209
210//struct Alignment2;
211
213
219struct AlignSVG { // : protected Align {
220
221
222 virtual
223 ~AlignSVG(){};
224
226
228 static
229 const HorzAlign LEFT; // ,Coord::MIN
230
232 static
234
236 static
238
240 static
242
243 static
244 const HorzAlign UNDEFINED_HORZ;
245
246 // ----------------------
247
249
251 static
253
255 static
257
259 static
261
263 static
265
266 static
267 const VertAlign UNDEFINED_VERT;
268
269
270 enum Owner {
271 OBJECT = 0, // 0b00001111,
272 ANCHOR = 1, // 0b11110000,
273 };
274
275
276 enum Topol {
277 INSIDE = 0,
278 OUTSIDE = 1,
279 UNDEFINED_TOPOL = 2,
280 };
281
282
284 /*
285 * Notice that for an alignment to be complete, this function should be called twice:
286 * setting partial alignment for both owner=OBJECT and owner=ANCHOR .
287 *
288 * \tparam OBJ - enum type \c Owner or string
289 * \tparam A - enum type \c Axis or string
290 * \tparam V - enum type \c Alignment or string
291 * \param pos - enum value \c OBJ or \c REF
292 * \param axis - enum value \c HORZ or \c VERT
293 * \param value - enum value \c MAX , \c MID , or \c MIN (or string)
294 */
295 template <typename OBJ, typename A, typename V>
296 inline // in problems, rename this function, ie. remove polymorphism
297 void setAlign(const OBJ & owner, const A & axis, const V &value){
298 modifyAlign(owner, axis, value);
299 updateAlign();
300 }
301
303
312 inline
313 void setAlign(const AlignBase::Axis & axis, const AlignBase::Pos & pos, Topol topol=Topol::INSIDE){
314 modifyAlign(ANCHOR, axis, pos);
315 modifyAlign(OBJECT, axis, (topol==INSIDE) ? pos : AlignBase::flip(pos));
316 updateAlign();
317 }
318
320 /*
321 * Template supports empty arg list.
322 *
323 * \tparam T - enum type \c Topol or string
324 * \tparam AX - axis enum type: Axis or const Axis
325 * \tparam A - axis enum value: HORZ, VERT or UNDEFINED_AXIS
326 * \param align - \c HorzAlign or \c VertAlign
327 */
328 template <typename ...T, typename AX, AlignBase::Axis A>
329 void setAlign(const Alignment<AX,A> & align, const T... args){
330 if (align.pos == AlignBase::FILL){
331 // Makes sense only for OBJECT, as it will be changed (and ANCHOR is never unchanged).
332 setAlign(AlignSVG::OBJECT, align.axis, align.pos);
333 }
334 else {
335 setAlign(align.axis, align.pos, args...);
336 }
337 }
338
339 // Convenience: set both horz and vert alignments (INSIDE)
340 /*
341 */
342 template <typename AX1, AlignBase::Axis A1, typename AX2, AlignBase::Axis A2>
343 void setAlign(const Alignment<AX1,A1> & align1, const Alignment<AX2,A2> & align2){
344 setAlign(align1.axis, align1.pos, AlignSVG::Topol::INSIDE);
345 setAlign(align2.axis, align2.pos, AlignSVG::Topol::INSIDE);
346 }
347
349 template <typename AX, AlignBase::Axis A>
350 void setAlign(const Alignment<AX,A> & align1, const Alignment<AX,A> & align2);
351
352
354 /*
355 * \tparam T - enum type \c Topol or string: \c INSIDE or \c OUTSIDE .
356 * \param align - Horizontal or vertical Alignment: \c LEFT|CENTER|RIGHT or \c TOP|MIDDLE|BOTTOM
357 * \param topol - \c INSIDE or \c OUTSIDE
358 */
359 template <typename T>
360 void setAlign(const std::string & align, const T & topol){
361 const Alignment<> & a = EnumDict<Alignment<> >::getValue(align, false);
362 const Topol & t = EnumDict<AlignSVG::Topol>::getValue(topol, false);
363 //const Alignment<> & a = EnumDict<Alignment<> >::getValue(align, false);
364 setAlign(a.axis, a.pos, t);
365 }
366
368
370 void setAlign(const std::string & align);
371 // Note: no mixed type, ANCHOR:LEFT
372
374 bool isAligned() const;
375
376 void resetAlign();
377
379 /*
380 * \tparam P - enum type Owner \c REF or \c OBJ , or respective string.
381 * \tparam A - enum type axis_t \c HORZ or \c VERT , or respective string.
382 * \param pos - target object \c OBJ or referred anchor object \c REF
383 * \param axis - horizontal \c HORZ or vertical \c AXIS .
384 */
385 template <typename P, typename A>
386 AlignBase::Pos & getAlign(const P & pos, const A & axis);
387
388
390 /*
391 * \tparam P - enum type Owner \c REF or \c OBJ , or respective string.
392 * \tparam A - enum type axis_t \c HORZ or \c VERT , or respective string.
393 * \param pos - target object \c OBJ or referred anchor object \c REF
394 * \param axis - horizontal \c HORZ or vertical \c AXIS .
395 *
396 */
397 template <typename P, typename A>
398 const AlignBase::Pos & getAlign(const P & pos, const A & axis) const;
399
403 void confToStream(std::ostream & ostr) const;
404
405 /*
407 template <typename ...TT>
408 bool isAlignSet(const TT... args) const {
409 bitvect_t v = combineAlign(args...);
410 return (alignment & v) == v;
411 }
412
413 */
414
415protected:
416
417 // Future extension
418 typedef int bitvect_t; // or int_t ?
419
420 // Future extension
421 mutable
422 bitvect_t alignment = 0;
423
425 template <typename P, typename A, typename V>
426 void modifyAlign(const P & owner, const A & axis, const V &value){
427 getAlign(owner, axis) = EnumDict<AlignBase::Pos>::getValue(value, false);
428 }
429
430 virtual inline
431 void updateAlign(){};
432
433
434 typedef std::vector<AlignBase::Pos> align_vect_t;
435 typedef std::vector<align_vect_t > align_conf_t;
436
437 align_conf_t alignments = align_conf_t(2, align_vect_t(2, AlignBase::Pos::UNDEFINED_POS));
438
440
441
442};
443
444
445inline
446std::ostream & operator<<(std::ostream &ostr, const AlignSVG & align){
447 //return ostr << align.axis << '_' << align.pos; // enums resolved above
448 align.confToStream(ostr);
449 return ostr; // << "UNDER CONSTR..."; // RESOLVE!
450}
451
452
453template <>
455DRAIN_ENUM_OSTREAM(AlignSVG::Owner);
456
457template <>
459DRAIN_ENUM_OSTREAM(AlignSVG::Topol);
460
461template <>
462inline
463void AlignSVG::HorzAlign::reset(){
464 // axis = AlignBase::Axis::UNDEFINED_AXIS;
465 pos = AlignBase::Pos::UNDEFINED_POS;
466}
467
468template <>
469inline
470void AlignSVG::VertAlign::reset(){
471 // axis = AlignBase::Axis::UNDEFINED_AXIS;
472 pos = AlignBase::Pos::UNDEFINED_POS;
473}
474
475DRAIN_TYPENAME(AlignSVG::HorzAlign);
476
477DRAIN_TYPENAME(AlignSVG::VertAlign);
478
480template <>
482// DRAIN_ENUM_OSTREAM(AlignSVG::HorzAlign);
483
485template <>
487// DRAIN_ENUM_OSTREAM(AlignSVG::VertAlign);
488
489
491template <>
493
494
495
496
497template <typename OBJ, typename A>
498AlignBase::Pos & AlignSVG::getAlign(const OBJ & owner, const A & axis){
499 const AlignSVG::Owner p = EnumDict<AlignSVG::Owner>::getValue(owner, false); // raise error
500 const AlignBase::Axis a = EnumDict<AlignBase::Axis>::getValue(axis, false); // raise error
501 return alignments[p][a];
502}
503
504template <typename OBJ, typename A>
505const AlignBase::Pos & AlignSVG::getAlign(const OBJ & owner, const A & axis) const {
506 const AlignSVG::Owner p = EnumDict<AlignSVG::Owner>::getValue(owner, false); // raise error
507 const AlignBase::Axis a = EnumDict<AlignBase::Axis>::getValue(axis, false); // raise error
508 return alignments[p][a];
509}
510
511
512
513
514
515
517
530template <typename AX = AlignBase::Axis, AlignBase::Axis A = AlignBase::Axis::UNDEFINED_AXIS> // , Align::Coord POS = Align::Coord::UNDEFINED_POS>
531struct CompleteAlignment : public Alignment<AX,A> {
532
533 AlignSVG::Topol topol = AlignSVG::Topol::INSIDE; // or undef?
534
536 template <class ...TT>
537 CompleteAlignment(const TT... args) : Alignment<AX,A>() {
538 set(args...);
539 }
540
541 inline
543
544 virtual inline
545 bool isSet() const {
546 return (this->axis != AlignBase::Axis::UNDEFINED_AXIS) &&
547 (this->pos != AlignBase::Pos::UNDEFINED_POS) &&
548 (topol != AlignSVG::Topol::UNDEFINED_TOPOL);
549 // return Alignment<AX,A>::isSet() && (topol != AlignSVG::Topol::UNDEFINED_TOPOL);
550 }
551
552 inline
553 const AlignSVG::Topol & get(const AlignSVG::Topol & defaultValue) const {
554 if (topol != AlignSVG::Topol::UNDEFINED_TOPOL){
555 return topol;
556 }
557 else {
558 return defaultValue;
559 }
560 }
561
562
563 // Sets all members to UNDEFINED state.
564 virtual inline
565 void reset(){
566 Alignment<AX,A>::reset();
567 topol = AlignSVG::Topol::UNDEFINED_TOPOL;
568 // this->updateAlign();
569 }
570
571
572 template <typename AX2, AlignBase::Axis A2, class ...TT>
573 void set(const Alignment<AX2,A2> & align, const TT... args){
574 this->axis = align.axis;
575 this->pos = align.pos;
576 set(args...);
577 }
578
579 template <class ...TT>
580 void set(AlignSVG::Topol topol, const TT... args){
581 this->topol = topol;
582 set(args...);
583 }
584
585 template <class ...TT>
586 void set(AlignBase::Axis axis, const TT... args){
587 this->axis = axis;
588 set(args...);
589 }
590
591 template <class ...TT>
592 void set(AlignBase::Pos coord, const TT... args){
593 this->pos = coord;
594 set(args...);
595 }
596
597 template <class ...TT>
598 void set(const std::string & key, const TT... args){
600 // ok
601 }
602 else if (EnumDict<Alignment<> >::setValue(key, *this)){ // RIGHT or?
603 // ok
604 }
605 else if (EnumDict<AlignBase::Axis>::setValue(key, this->axis)){
606 // ok
607 }
608 else if (EnumDict<AlignBase::Pos>::setValue(key, this->pos)){
609 // ok
610 }
611 else {
612 // Advice: keys
613 throw std::runtime_error(drain::StringBuilder<>("key '", key, "' not found. Appeared in: ", args...));
614 }
615
616 set(args...);
617 }
618
619 template <class ...TT>
620 void set(const char *key, const TT... args){
621 set(std::string(key), args...);
622 }
623
624
625protected:
626
627 inline
628 void set(){
629 // this->updateAlign(); // ok?
630 }
631
632};
633
634
635
636template <typename AX, AlignBase::Axis A>
637std::ostream & operator<<(std::ostream &ostr, const CompleteAlignment<AX,A> & ad){
638 return ostr << ad.topol << '_' << ad.axis << ':' << ad.pos;
639}
640
641
643
647
648public:
649
650
651 //enum Axis {HORZ=0, VERT=1}; // must be indexed! for vect_ UNDEFINED_AXIS=0,
653 AxisFlagger orientation = AlignBase::HORZ;
654
655 enum Direction {
656 UNDEFINED_DIRECTION=0,
657 INCR = 1,
658 DECR = 2,
659 };
661 DirectionFlagger direction = INCR;
662
663 // Experimental CSS classes
664 enum GroupType {
665 HEADER,
666 ALIGN_FRAME,
667 // ALI GNED, // needed? "anchor" attrib and getAlign() should work
668 ABSOLUTE, // "do not align (me or descendants) (future option)"
669 FLOAT, // = element does not affect alignment of other elems
670 };
671
672
673 inline
674 LayoutSVG(AlignBase::Axis v=AlignBase::HORZ, Direction d=INCR) : orientation(v), direction(d) {
675 }
676
677 inline
678 LayoutSVG(const LayoutSVG & layout) : orientation(layout.orientation), direction(layout.direction){
679 }
680
681 template <typename V>
682 inline
683 void setOrientation(const V &v){
684 orientation.set(EnumDict<AlignBase::Axis>::getValue(v));
685 };
686
687 template <typename D>
688 inline
689 void setDirection(const D & d){
691 };
692
694
697 template <typename D, typename V>
698 inline
699 void set(const D & d, const V &v){
701 orientation.set(EnumDict<AlignBase::Axis>::getValue(v));
702 };
703
704
705 /*
706 static inline
707 Direction flip(Direction ...){
708 return ...
709 };
710 */
711
712
713
714};
715
716
717
718template <>
720DRAIN_ENUM_OSTREAM(LayoutSVG::Direction);
721
722template<>
724DRAIN_ENUM_OSTREAM(LayoutSVG::GroupType);
725
726
727
728
730struct AlignAdapterSVG : public AlignSVG {
731
733 template <class T>
734 inline
735 void setAlignAnchor(const T & pathElem){
736 anchorVert = anchorHorz = getElem(pathElem);
737 updateAlign();
738 }
739
740 template <class T>
741 inline
742 void setAlignAnchorHorz(const T & pathElem){
743 anchorHorz = getElem(pathElem);
744 updateAlign();
745 }
746
747 template <class T>
748 inline
749 void setAlignAnchorVert(const T & pathElem){
750 anchorVert = getElem(pathElem);
751 updateAlign();
752 }
753
755 inline
756 const std::string & getAlignAnchorHorz() const {
757 return anchorHorz;
758 }
759
760 inline
761 const std::string & getAlignAnchorVert() const {
762 return anchorVert;
763 }
764
765 inline
766 const std::string & getAlignStr() const {
767 return alignStr;
768 }
769
770 inline virtual
771 ~AlignAdapterSVG(){};
772
773protected:
774
775 static inline
776 const std::string & getElem(const std::string &s){
777 return s;
778 };
779
780 static inline
781 const char * getElem(const char *s){
782 return s;
783 };
784
785 template <class T>
786 static inline
787 const std::string & getElem(const T & type){
788 return EnumDict<T>::dict.getKey(type, false);
789 }
790
791
792 virtual inline
793 void updateAlign() override {
794 updateAlignStr();
795 }
796
797 std::string alignStr;
798
799 std::string anchorHorz;
800 std::string anchorVert;
801
802 void updateAlignStr();
803
804};
805
806
807
808
809
810
811} // image::
812
813} // drain::
814
815
816DRAIN_ENUM_OSTREAM(drain::image::AlignBase::Axis);
817DRAIN_ENUM_OSTREAM(drain::image::AlignBase::Pos);
818
819DRAIN_ENUM_OSTREAM(drain::image::AlignSVG::Owner);
820
821DRAIN_ENUM_OSTREAM(drain::image::LayoutSVG::Direction);
822
823
824#endif // DRAIN_ALIGN_SVG_H_
825
Two-way mapping between strings and objects of template class T.
Definition Dictionary.h:63
Flagger accepting values of enum type E.
Definition EnumFlags.h:182
Definition StringBuilder.h:58
Higher level controller for setting alignments.
Definition AlignSVG.h:646
void set(const D &d, const V &v)
Set direction and orientation.
Definition AlignSVG.h:699
Definition DataSelector.cpp:1277
DRAIN_TYPENAME(void)
Add a specialization for each type of those you want to support.
A container for a static dictionary of enumeration values.
Definition EnumFlags.h:69
static E getValue(const E &value, bool lenient=true)
Convenience for object.set(...) like commands.
Definition EnumFlags.h:114
static bool setValue(const std::string &key, E &value)
Assign string values to an enumeration type.
Definition EnumFlags.h:96
Adapter designed for NodeSVG.
Definition AlignSVG.h:730
void setAlignAnchor(const T &pathElem)
Mark one of the elements of this object (SVG or G) as a decisive position.
Definition AlignSVG.h:735
Low level alignment instructions.
Definition AlignSVG.h:53
Pos
Reference position at Axis (HORZ or VERT)
Definition AlignSVG.h:58
User-friendly programming interface for alignment considering two elements.
Definition AlignSVG.h:219
static const HorzAlign LEFT
Alias for {HORZ:MIN}.
Definition AlignSVG.h:229
static const VertAlign MIDDLE
Alias for {VERT:MID}.
Definition AlignSVG.h:256
void setAlign(const std::string &align, const T &topol)
High-level, user friendlier interface for setting the alignments for both OBJECT itself and its ANCHO...
Definition AlignSVG.h:360
void setAlign(const OBJ &owner, const A &axis, const V &value)
Low-level, "atomic" setter of alignment for OBJECT itself or its ANCHOR object.
Definition AlignSVG.h:297
void setAlign(const AlignBase::Axis &axis, const AlignBase::Pos &pos, Topol topol=Topol::INSIDE)
Set a single alignment setting. "Intermediate-level": axis and pos are given separately.
Definition AlignSVG.h:313
const AlignBase::Pos & getAlign(const P &pos, const A &axis) const
Return alignment setting of an object along horizontal or vertical axis .
void confToStream(std::ostream &ostr) const
Definition AlignSVG.cpp:181
bool isAligned() const
Returns true, if any setting is set...
Definition AlignSVG.cpp:274
static const HorzAlign RIGHT
Alias for {HORZ:MAX}.
Definition AlignSVG.h:237
static const HorzAlign HORZ_FILL
Alias for {HORZ:FILL}.
Definition AlignSVG.h:241
void setAlign(const Alignment< AX, A > &align1, const Alignment< AX, A > &align2)
Compiler trap: unimplemented for two of same kind: either HorzAlign or VertAlign twice.
void modifyAlign(const P &owner, const A &axis, const V &value)
Change alignment configuration without updating the alignStr.
Definition AlignSVG.h:426
static const VertAlign VERT_FILL
Alias for {VERT:FILL}.
Definition AlignSVG.h:264
static const VertAlign BOTTOM
Alias for {VERT:MAX}.
Definition AlignSVG.h:260
void setAlign(const Alignment< AX, A > &align, const T... args)
NEW High-level, user friendlier interface for setting INSIDE the alignments for both OBJECT itself an...
Definition AlignSVG.h:329
static const HorzAlign CENTER
Alias for {HORZ:MID}.
Definition AlignSVG.h:233
static const VertAlign TOP
Alias for {VERT:MIN}.
Definition AlignSVG.h:252
AlignBase::Pos & getAlign(const P &pos, const A &axis)
Return alignment setting of an object along horizontal or vertical axis .
Container for Axis and Pos.
Definition AlignSVG.h:126
Alignment(const Alignment &ac)
Copy constructor.
Definition AlignSVG.h:141
Alignment(AlignBase::Pos pos=AlignBase::Pos::UNDEFINED_POS)
Default constructor.
Definition AlignSVG.h:136
virtual ~Alignment()
Destructor.
Definition AlignSVG.h:157
"Alternative" partial alignment configuration for single object. Partial means that either OBJECT its...
Definition AlignSVG.h:531
CompleteAlignment(const TT... args)
Constructor not setting Axis.
Definition AlignSVG.h:537