Crazy Eddie's GUI System 0.8.7
PropertyHelper.h
1/***********************************************************************
2 created: 21/11/2010
3 author: Martin Preisler (reworked from code by Paul D Turner)
4
5 purpose: Interface to the PropertyHelper class
6*************************************************************************/
7/***************************************************************************
8 * Copyright (C) 2004 - 2006 Paul D Turner & The CEGUI Development Team
9 *
10 * Permission is hereby granted, free of charge, to any person obtaining
11 * a copy of this software and associated documentation files (the
12 * "Software"), to deal in the Software without restriction, including
13 * without limitation the rights to use, copy, modify, merge, publish,
14 * distribute, sublicense, and/or sell copies of the Software, and to
15 * permit persons to whom the Software is furnished to do so, subject to
16 * the following conditions:
17 *
18 * The above copyright notice and this permission notice shall be
19 * included in all copies or substantial portions of the Software.
20 *
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
22 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
24 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
25 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
26 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
27 * OTHER DEALINGS IN THE SOFTWARE.
28 ***************************************************************************/
29#ifndef _CEGUIPropertyHelper_h_
30#define _CEGUIPropertyHelper_h_
31
32#include "CEGUI/String.h"
33#include "CEGUI/Size.h"
34#include "CEGUI/Vector.h"
35#include "CEGUI/Quaternion.h"
36#include "CEGUI/Colour.h"
37#include "CEGUI/ColourRect.h"
38#include "CEGUI/UDim.h"
39#include "CEGUI/Rect.h"
40
41
42#include <cstdio>
43
44#include <sstream>
45
46#if defined(_MSC_VER)
47# pragma warning(push)
48# pragma warning(disable : 4996)
49#endif
50
51#ifdef _MSC_VER
52 #define snprintf _snprintf
53#endif
54
55#ifdef __MINGW32__
56
57 #if __USE_MINGW_ANSI_STDIO != 1
58 #warning __USE_MINGW_ANSI_STDIO must be set to 1 for sscanf and snprintf to work with 64bit integers
59 #endif
60
61 #pragma GCC diagnostic push
62
63 /* Due to a bug in MinGW-w64, a false warning is sometimes issued when using
64 "%llu" format with the "printf"/"scanf" family of functions. */
65 #pragma GCC diagnostic ignored "-Wformat"
66 #pragma GCC diagnostic ignored "-Wformat-extra-args"
67
68#endif
69
70namespace CEGUI
71{
72
83template<typename T>
84class PropertyHelper;
85
86// this redirects PropertyHelper<const T> to PropertyHelper<T>
87template<typename T>
88class PropertyHelper<const T>
89{
90public:
91 typedef typename PropertyHelper<T>::return_type return_type;
92 typedef typename PropertyHelper<T>::safe_method_return_type safe_method_return_type;
93 typedef typename PropertyHelper<T>::pass_type pass_type;
94 typedef typename PropertyHelper<T>::string_return_type string_return_type;
95
96 static inline const String& getDataTypeName()
97 {
99 }
100
101 static inline return_type fromString(const String& str)
102 {
104 }
105
106 static inline String toString(pass_type val)
107 {
108 return PropertyHelper<T>::toString(val);
109 }
110};
111
112// this redirects PropertyHelper<const T&> to PropertyHelper<T>
113template<typename T>
114class PropertyHelper<const T&>
115{
116public:
117 typedef typename PropertyHelper<T>::return_type return_type;
118 typedef typename PropertyHelper<T>::safe_method_return_type safe_method_return_type;
119 typedef typename PropertyHelper<T>::pass_type pass_type;
120 typedef typename PropertyHelper<T>::string_return_type string_return_type;
121
122 static inline const String& getDataTypeName()
123 {
125 }
126
127 static inline return_type fromString(const String& str)
128 {
130 }
131
132 static inline String toString(pass_type val)
133 {
134 return PropertyHelper<T>::toString(val);
135 }
136};
137
138// this redirects PropertyHelper<const T*> to PropertyHelper<T*>
139template<typename T>
140class PropertyHelper<const T*>
141{
142public:
143 typedef typename PropertyHelper<T*>::return_type return_type;
144 typedef typename PropertyHelper<T*>::safe_method_return_type safe_method_return_type;
145 typedef typename PropertyHelper<T*>::pass_type pass_type;
146 typedef typename PropertyHelper<T*>::string_return_type string_return_type;
147
148 static inline const String& getDataTypeName()
149 {
151 }
152
153 static inline return_type fromString(const String& str)
154 {
156 }
157
158 static inline String toString(pass_type val)
159 {
161 }
162};
163
164template<>
166{
167public:
168 typedef const String& return_type;
170 typedef const String& pass_type;
171 typedef const String& string_return_type;
172
173 static const String& getDataTypeName()
174 {
175 static String type("String");
176
177 return type;
178 }
179
180 static inline return_type fromString(const String& str)
181 {
182 return str;
183 }
184
185 static inline string_return_type toString(pass_type val)
186 {
187 return val;
188 }
189};
190
191template<>
192class PropertyHelper<float>
193{
194public:
195 typedef float return_type;
196 typedef return_type safe_method_return_type;
197 typedef const float pass_type;
199
200 static const String& getDataTypeName()
201 {
202 static String type("float");
203
204 return type;
205 }
206
207 static inline return_type fromString(const String& str)
208 {
209 float val = 0;
210 sscanf(str.c_str(), " %g", &val);
211
212 return val;
213 }
214
215 static inline string_return_type toString(pass_type val)
216 {
217 char buff[64];
218 snprintf(buff, sizeof(buff), "%g", val);
219
220 return String(buff);
221 }
222};
223template<>
224class PropertyHelper<double>
225{
226public:
227 typedef double return_type;
228 typedef return_type safe_method_return_type;
229 typedef const double pass_type;
231
232 static const String& getDataTypeName()
233 {
234 static String type("double");
235
236 return type;
237 }
238
239 static inline return_type fromString(const String& str)
240 {
241 double val = 0;
242 sscanf(str.c_str(), " %lg", &val);
243
244 return val;
245 }
246
247 static inline string_return_type toString(pass_type val)
248 {
249 char buff[64];
250 snprintf(buff, sizeof(buff), "%g", val);
251
252 return String(buff);
253 }
254};
255
256template<>
258{
259public:
260 typedef int return_type;
261 typedef return_type safe_method_return_type;
262 typedef const int pass_type;
264
265 static const String& getDataTypeName()
266 {
267 static String type("int");
268
269 return type;
270 }
271
272 static inline return_type fromString(const String& str)
273 {
274 int val = 0;
275 sscanf(str.c_str(), " %d", &val);
276
277 return val;
278 }
279
280 static inline string_return_type toString(pass_type val)
281 {
282 char buff[64];
283 snprintf(buff, sizeof(buff), "%d", val);
284
285 return String(buff);
286 }
287};
288
289template<>
290class PropertyHelper<uint>
291{
292public:
293 typedef uint return_type;
294 typedef return_type safe_method_return_type;
295 typedef const uint pass_type;
297
298 static const String& getDataTypeName()
299 {
300 static String type("uint");
301
302 return type;
303 }
304
305 static return_type fromString(const String& str)
306 {
307 uint val = 0;
308 sscanf(str.c_str(), " %u", &val);
309
310 return val;
311 }
312
313 static string_return_type toString(pass_type val)
314 {
315 char buff[64];
316 snprintf(buff, sizeof(buff), "%u", val);
317
318 return String(buff);
319 }
320};
321
322template<>
323class PropertyHelper<uint64>
324{
325public:
326 typedef uint64 return_type;
327 typedef return_type safe_method_return_type;
328 typedef const uint64 pass_type;
330
331 static const String& getDataTypeName()
332 {
333 static String type("uint64");
334
335 return type;
336 }
337
338 static return_type fromString(const String& str)
339 {
340 uint64 val = 0;
341 sscanf(str.c_str(), " %llu", &val);
342
343 return val;
344 }
345
346 static string_return_type toString(pass_type val)
347 {
348 char buff[64];
349 snprintf(buff, sizeof(buff), "%llu", val);
350
351 return String(buff);
352 }
353};
354
355#if CEGUI_STRING_CLASS != CEGUI_STRING_CLASS_UNICODE
356
357template<>
358class PropertyHelper<String::value_type>
359{
360public:
361 typedef String::value_type return_type;
362 typedef return_type safe_method_return_type;
363 typedef const String::value_type pass_type;
364 typedef String string_return_type;
365
366 static const String& getDataTypeName()
367 {
368 static String type("char");
369
370 return type;
371 }
372
373 static return_type fromString(const String& str)
374 {
375 return str[0];
376 }
377
378 static string_return_type toString(pass_type val)
379 {
380 return String("") + val;
381 }
382};
383
384#endif
385
386template<>
387class PropertyHelper<unsigned long>
388{
389public:
390 typedef unsigned long return_type;
391 typedef return_type safe_method_return_type;
392 typedef const unsigned long pass_type;
394
395 static const String& getDataTypeName()
396 {
397 static String type("unsigned long");
398
399 return type;
400 }
401
402 static return_type fromString(const String& str)
403 {
404 unsigned long val = 0;
405 sscanf(str.c_str(), " %lu", &val);
406
407 return val;
408 }
409
410 static string_return_type toString(pass_type val)
411 {
412 char buff[64];
413 snprintf(buff, sizeof(buff), "%lu", val);
414
415 return String(buff);
416 }
417};
418
419template<>
420class CEGUIEXPORT PropertyHelper<bool>
421{
422public:
423 typedef bool return_type;
424 typedef return_type safe_method_return_type;
425 typedef const bool pass_type;
426 typedef const String& string_return_type;
427
428 static const String& getDataTypeName()
429 {
430 static String type("bool");
431
432 return type;
433 }
434
435 static return_type fromString(const String& str)
436 {
437 return (str == True || str == "True");
438 }
439
440 static string_return_type toString(pass_type val)
441 {
442 return val ? True : False;
443 }
444
446 static const CEGUI::String True;
447 static const CEGUI::String False;
448};
449
450
451
452template<>
453class CEGUIEXPORT PropertyHelper<AspectMode>
454{
455public:
456 typedef AspectMode return_type;
458 typedef AspectMode pass_type;
460
461 static const String& getDataTypeName()
462 {
463 static String type("AspectMode");
464
465 return type;
466 }
467
468 static return_type fromString(const String& str)
469 {
470 if (str == Shrink)
471 {
472 return AM_SHRINK;
473 }
474 else if (str == Expand)
475 {
476 return AM_EXPAND;
477 }
478 else
479 {
480 return AM_IGNORE;
481 }
482 }
483
484 static string_return_type toString(pass_type val)
485 {
486 if (val == AM_IGNORE)
487 {
488 return Ignore;
489 }
490 else if (val == AM_SHRINK)
491 {
492 return Shrink;
493 }
494 else if (val == AM_EXPAND)
495 {
496 return Expand;
497 }
498 else
499 {
500 assert(false && "Invalid aspect mode");
501 return Ignore;
502 }
503 }
504
506 static const CEGUI::String Shrink;
507 static const CEGUI::String Expand;
508 static const CEGUI::String Ignore;
509};
510
511template<>
513{
514public:
515 typedef Sizef return_type;
517 typedef const Sizef& pass_type;
519
520 static const String& getDataTypeName()
521 {
522 static String type("Sizef");
523
524 return type;
525 }
526
527 static return_type fromString(const String& str)
528 {
529 Sizef val(0, 0);
530 sscanf(str.c_str(), " w:%g h:%g", &val.d_width, &val.d_height);
531
532 return val;
533 }
534
535 static string_return_type toString(pass_type val)
536 {
537 char buff[128];
538 snprintf(buff, sizeof(buff), "w:%g h:%g", val.d_width, val.d_height);
539
540 return String(buff);
541 }
542};
543
544template<>
546{
547public:
548 typedef Vector2f return_type;
550 typedef const Vector2f& pass_type;
552
553 static const String& getDataTypeName()
554 {
555 static String type("Vector2f");
556
557 return type;
558 }
559
560 static return_type fromString(const String& str)
561 {
562 Vector2f val(0, 0) ;
563 sscanf(str.c_str(), " x:%g y:%g", &val.d_x, &val.d_y);
564
565 return val;
566 }
567
568 static string_return_type toString(pass_type val)
569 {
570 char buff[128];
571 snprintf(buff, sizeof(buff), "x:%g y:%g", val.d_x, val.d_y);
572
573 return String(buff);
574 }
575};
576
577template<>
579{
580public:
581 typedef Vector3f return_type;
583 typedef const Vector3f& pass_type;
585
586 static const String& getDataTypeName()
587 {
588 static String type("Vector3f");
589
590 return type;
591 }
592
593 static return_type fromString(const String& str)
594 {
595 Vector3f val(0, 0, 0);
596 sscanf(str.c_str(), " x:%g y:%g z:%g", &val.d_x, &val.d_y, &val.d_z);
597
598 return val;
599 }
600
601 static string_return_type toString(pass_type val)
602 {
603 char buff[128];
604 snprintf(buff, sizeof(buff), "x:%g y:%g z:%g", val.d_x, val.d_y, val.d_z);
605
606 return String(buff);
607 }
608};
609
610template<>
612{
613public:
614 typedef Quaternion return_type;
616 typedef const Quaternion& pass_type;
618
619 static const String& getDataTypeName()
620 {
621 static String type("Quaternion");
622
623 return type;
624 }
625
626 static return_type fromString(const String& str)
627 {
628 if (strchr(str.c_str(), 'w') || strchr(str.c_str(), 'W'))
629 {
630 Quaternion val(1, 0, 0, 0);
631 sscanf(str.c_str(), " w:%g x:%g y:%g z:%g", &val.d_w, &val.d_x, &val.d_y, &val.d_z);
632
633 return val;
634 }
635 else
636 {
637 float x, y, z;
638 sscanf(str.c_str(), " x:%g y:%g z:%g", &x, &y, &z);
639 return Quaternion::eulerAnglesDegrees(x, y, z);
640 }
641 }
642
643 static string_return_type toString(pass_type val)
644 {
645 char buff[128];
646 snprintf(buff, sizeof(buff), "w:%g x:%g y:%g z:%g", val.d_w, val.d_x, val.d_y, val.d_z);
647
648 return String(buff);
649 }
650};
651
652template<>
654{
655public:
656 typedef Rectf return_type;
658 typedef const Rectf& pass_type;
660
661 static const String& getDataTypeName()
662 {
663 static String type("Rectf");
664
665 return type;
666 }
667
668 static return_type fromString(const String& str)
669 {
670 Rectf val(0, 0, 0, 0);
671 sscanf(str.c_str(), " l:%g t:%g r:%g b:%g", &val.d_min.d_x, &val.d_min.d_y, &val.d_max.d_x, &val.d_max.d_y);
672
673 return val;
674 }
675
676 static string_return_type toString(pass_type val)
677 {
678 char buff[256];
679 snprintf(buff, sizeof(buff), "l:%g t:%g r:%g b:%g",
680 val.d_min.d_x, val.d_min.d_y, val.d_max.d_x, val.d_max.d_y);
681
682 return String(buff);
683 }
684};
685
686template<>
687class CEGUIEXPORT PropertyHelper<Image*>
688{
689public:
690 typedef const Image* return_type;
692 typedef const Image* const pass_type;
694
695 static const String& getDataTypeName()
696 {
697 static String type("Image");
698
699 return type;
700 }
701
702 static return_type fromString(const String& str);
703
704 static string_return_type toString(pass_type val);
705};
706
707template<>
709{
710public:
711 typedef Colour return_type;
713 typedef const Colour& pass_type;
715
716 static const String& getDataTypeName()
717 {
718 static String type("Colour");
719
720 return type;
721 }
722
723 static return_type fromString(const String& str)
724 {
725 argb_t val = 0xFF000000;
726 sscanf(str.c_str(), " %8X", &val);
727
728 return Colour(val);
729 }
730
731 static string_return_type toString(pass_type val)
732 {
733 char buff[16];
734 sprintf(buff, "%.8X", val.getARGB());
735
736 return String(buff);
737 }
738};
739
740template<>
742{
743public:
744 typedef ColourRect return_type;
746 typedef const ColourRect& pass_type;
748
749 static const String& getDataTypeName()
750 {
751 static String type("ColourRect");
752
753 return type;
754 }
755
756 static return_type fromString(const String& str)
757 {
758 if (str.length() == 8)
759 {
760 argb_t all = 0xFF000000;
761 sscanf(str.c_str(), "%8X", &all);
762 return ColourRect(all);
763 }
764
765 argb_t topLeft = 0xFF000000, topRight = 0xFF000000, bottomLeft = 0xFF000000, bottomRight = 0xFF000000;
766 sscanf(str.c_str(), "tl:%8X tr:%8X bl:%8X br:%8X", &topLeft, &topRight, &bottomLeft, &bottomRight);
767
768 return ColourRect(topLeft, topRight, bottomLeft, bottomRight);
769 }
770
771 static string_return_type toString(pass_type val)
772 {
773 char buff[64];
774 sprintf(buff, "tl:%.8X tr:%.8X bl:%.8X br:%.8X", val.d_top_left.getARGB(), val.d_top_right.getARGB(), val.d_bottom_left.getARGB(), val.d_bottom_right.getARGB());
775
776 return String(buff);
777 }
778};
779
780template<>
782{
783public:
784 typedef UDim return_type;
786 typedef const UDim& pass_type;
788
789 static const String& getDataTypeName()
790 {
791 static String type("UDim");
792
793 return type;
794 }
795
796 static return_type fromString(const String& str)
797 {
798 UDim ud;
799 sscanf(str.c_str(), " { %g , %g }", &ud.d_scale, &ud.d_offset);
800
801 return ud;
802 }
803
804 static string_return_type toString(pass_type val)
805 {
806 char buff[128];
807 snprintf(buff, sizeof(buff), "{%g,%g}", val.d_scale, val.d_offset);
808
809 return String(buff);
810 }
811};
812
813template<>
815{
816public:
817 typedef UVector2 return_type;
819 typedef const UVector2& pass_type;
821
822 static const String& getDataTypeName()
823 {
824 static String type("UVector2");
825
826 return type;
827 }
828
829 static return_type fromString(const String& str)
830 {
831 UVector2 uv;
832 sscanf(str.c_str(), " { { %g , %g } , { %g , %g } }",
833 &uv.d_x.d_scale, &uv.d_x.d_offset,
834 &uv.d_y.d_scale, &uv.d_y.d_offset);
835
836 return uv;
837 }
838
839 static string_return_type toString(pass_type val)
840 {
841 char buff[256];
842 snprintf(buff, sizeof(buff), "{{%g,%g},{%g,%g}}",
843 val.d_x.d_scale, val.d_x.d_offset, val.d_y.d_scale, val.d_y.d_offset);
844
845 return String(buff);
846 }
847};
848
849template<>
851{
852public:
853 typedef USize return_type;
855 typedef const USize& pass_type;
857
858 static const String& getDataTypeName()
859 {
860 static String type("USize");
861
862 return type;
863 }
864
865 static return_type fromString(const String& str)
866 {
867 USize uv;
868 sscanf(str.c_str(), " { { %g , %g } , { %g , %g } }",
869 &uv.d_width.d_scale, &uv.d_width.d_offset,
870 &uv.d_height.d_scale, &uv.d_height.d_offset);
871
872 return uv;
873 }
874
875 static string_return_type toString(pass_type val)
876 {
877 char buff[256];
878 snprintf(buff, sizeof(buff), "{{%g,%g},{%g,%g}}",
879 val.d_width.d_scale, val.d_width.d_offset, val.d_height.d_scale, val.d_height.d_offset);
880
881 return String(buff);
882 }
883};
884
885template<>
887{
888public:
889 typedef URect return_type;
891 typedef const URect& pass_type;
893
894 static const String& getDataTypeName()
895 {
896 static String type("URect");
897
898 return type;
899 }
900
901 static return_type fromString(const String& str)
902 {
903 URect ur;
904 sscanf(
905 str.c_str(),
906 " { { %g , %g } , { %g , %g } , { %g , %g } , { %g , %g } }",
907 &ur.d_min.d_x.d_scale, &ur.d_min.d_x.d_offset,
908 &ur.d_min.d_y.d_scale, &ur.d_min.d_y.d_offset,
909 &ur.d_max.d_x.d_scale, &ur.d_max.d_x.d_offset,
910 &ur.d_max.d_y.d_scale, &ur.d_max.d_y.d_offset
911 );
912
913 return ur;
914 }
915
916 static string_return_type toString(pass_type val)
917 {
918 char buff[512];
919 snprintf(buff, sizeof(buff), "{{%g,%g},{%g,%g},{%g,%g},{%g,%g}}",
920 val.d_min.d_x.d_scale, val.d_min.d_x.d_offset,
921 val.d_min.d_y.d_scale, val.d_min.d_y.d_offset,
922 val.d_max.d_x.d_scale, val.d_max.d_x.d_offset,
923 val.d_max.d_y.d_scale, val.d_max.d_y.d_offset);
924
925 return String(buff);
926 }
927};
928
929template<>
931{
932public:
933 typedef UBox return_type;
935 typedef const UBox& pass_type;
937
938 static const String& getDataTypeName()
939 {
940 static String type("UBox");
941
942 return type;
943 }
944
945 static return_type fromString(const String& str)
946 {
947 UBox ret;
948 sscanf(
949 str.c_str(),
950 " { top: { %g , %g } , left: { %g , %g } , bottom: { %g , %g } , right: { %g , %g } }",
951 &ret.d_top.d_scale, &ret.d_top.d_offset,
952 &ret.d_left.d_scale, &ret.d_left.d_offset,
953 &ret.d_bottom.d_scale, &ret.d_bottom.d_offset,
954 &ret.d_right.d_scale, &ret.d_right.d_offset
955 );
956
957 return ret;
958 }
959
960 static string_return_type toString(pass_type val)
961 {
962 char buff[512];
963 snprintf(buff, sizeof(buff), "{top:{%g,%g},left:{%g,%g},bottom:{%g,%g},right:{%g,%g}}",
964 val.d_top.d_scale, val.d_top.d_offset,
965 val.d_left.d_scale, val.d_left.d_offset,
966 val.d_bottom.d_scale, val.d_bottom.d_offset,
967 val.d_right.d_scale, val.d_right.d_offset);
968
969 return String(buff);
970 }
971};
972
973
974template<>
975class CEGUIEXPORT PropertyHelper<Font*>
976{
977public:
978 typedef const Font* return_type;
980 typedef const Font* const pass_type;
982
983 static const String& getDataTypeName()
984 {
985 static String type("Font");
986
987 return type;
988 }
989
990 static return_type fromString(const String& str);
991 static string_return_type toString(pass_type val);
992};
993
994}
995
996#ifdef __MINGW32__
997 #pragma GCC diagnostic pop
998#endif
999
1000#if defined(_MSC_VER)
1001 #pragma warning(pop)
1002#endif
1003
1004#endif
Class that holds details of colours for the four corners of a rectangle.
Definition: ColourRect.h:45
Colour d_bottom_right
ColourRect component colours.
Definition: ColourRect.h:222
Class representing colour values within the system.
Definition: Colour.h:46
Class that encapsulates a typeface.
Definition: Font.h:62
Interface for Image.
Definition: Image.h:161
static const CEGUI::String Shrink
Definitions of the possible values represented as Strings.
Definition: PropertyHelper.h:506
static const CEGUI::String True
Definitions of the possible values represented as Strings.
Definition: PropertyHelper.h:446
Helper class used to convert various data types to and from the format expected in Property strings.
Definition: ForwardRefs.h:84
Class to represent rotation, avoids Gimbal lock.
Definition: Quaternion.h:69
float d_x
x component of the vector part
Definition: Quaternion.h:259
float d_y
y component of the vector part
Definition: Quaternion.h:261
static Quaternion eulerAnglesDegrees(float x, float y, float z)
constructs a quaternion from euler angles in degrees
float d_w
imaginary part
Definition: Quaternion.h:257
float d_z
z component of the vector part
Definition: Quaternion.h:263
String class used within the GUI system.
Definition: String.h:64
utf32 value_type
Basic 'code point' type used for String (utf32)
Definition: String.h:69
size_type length(void) const
Returns the size of the String in code points.
Definition: String.h:621
const char * c_str(void) const
Returns contents of the String as a null terminated string of utf8 encoded data.
Definition: String.h:1143
Class encapsulating the 'Unified Box' - this is usually used for margin.
Definition: UDim.h:249
Dimension that has both a relative 'scale' portion and and absolute 'offset' portion.
Definition: UDim.h:94
Main namespace for Crazy Eddie's GUI Library.
Definition: arch_overview.dox:1
AspectMode
How aspect ratio should be maintained.
Definition: Size.h:46
@ AM_SHRINK
Definition: Size.h:53
@ AM_EXPAND
Definition: Size.h:58
@ AM_IGNORE
Ignores the target aspect (default)
Definition: Size.h:48
uint32 argb_t
32 bit ARGB representation of a colour.
Definition: Colour.h:38