|
| enum | {
kNoInterface = -1,
kResultOk,
kResultTrue = kResultOk,
kResultFalse,
kInvalidArgument,
kNotImplemented,
kInternalError,
kNotInitialized,
kOutOfMemory
} |
| |
| enum | Direction {
kNorth,
kNorthEast,
kEast,
kSouthEast,
kSouth,
kSouthWest,
kWest,
kNorthWest,
kNoDirection,
kNumberOfDirections
} |
| |
| enum | Orientation { kHorizontal,
kVertical,
kNumberOfOrientations
} |
| |
| enum | VirtualKeyCodes {
KEY_BACK = 1,
KEY_TAB,
KEY_CLEAR,
KEY_RETURN,
KEY_PAUSE,
KEY_ESCAPE,
KEY_SPACE,
KEY_NEXT,
KEY_END,
KEY_HOME,
KEY_LEFT,
KEY_UP,
KEY_RIGHT,
KEY_DOWN,
KEY_PAGEUP,
KEY_PAGEDOWN,
KEY_SELECT,
KEY_PRINT,
KEY_ENTER,
KEY_SNAPSHOT,
KEY_INSERT,
KEY_DELETE,
KEY_HELP,
KEY_NUMPAD0,
KEY_NUMPAD1,
KEY_NUMPAD2,
KEY_NUMPAD3,
KEY_NUMPAD4,
KEY_NUMPAD5,
KEY_NUMPAD6,
KEY_NUMPAD7,
KEY_NUMPAD8,
KEY_NUMPAD9,
KEY_MULTIPLY,
KEY_ADD,
KEY_SEPARATOR,
KEY_SUBTRACT,
KEY_DECIMAL,
KEY_DIVIDE,
KEY_F1,
KEY_F2,
KEY_F3,
KEY_F4,
KEY_F5,
KEY_F6,
KEY_F7,
KEY_F8,
KEY_F9,
KEY_F10,
KEY_F11,
KEY_F12,
KEY_NUMLOCK,
KEY_SCROLL,
KEY_SHIFT,
KEY_CONTROL,
KEY_ALT,
KEY_EQUALS,
KEY_CONTEXTMENU,
KEY_MEDIA_PLAY,
KEY_MEDIA_STOP,
KEY_MEDIA_PREV,
KEY_MEDIA_NEXT,
KEY_VOLUME_UP,
KEY_VOLUME_DOWN,
KEY_F13,
KEY_F14,
KEY_F15,
KEY_F16,
KEY_F17,
KEY_F18,
KEY_F19,
KEY_F20,
KEY_F21,
KEY_F22,
KEY_F23,
KEY_F24,
KEY_SUPER,
VKEY_FIRST_CODE = KEY_BACK,
VKEY_LAST_CODE = KEY_SUPER,
VKEY_FIRST_ASCII = 128
} |
| | Virtual Key Codes. More...
|
| |
| enum | KeyModifier { kShiftKey = 1 << 0,
kAlternateKey = 1 << 1,
kCommandKey = 1 << 2,
kControlKey = 1 << 3
} |
| | OS-independent enumeration of virtual modifier-codes. More...
|
| |
| enum | StandardColor {
kBlack = 0,
kWhite,
kGray5,
kGray10,
kGray20,
kGray30,
kGray40,
kGray50,
kGray60,
kGray70,
kGray80,
kGray90,
kRed,
kLtRed,
kDkRed,
kGreen,
kLtGreen,
kDkGreen,
kBlue,
kLtBlue,
kDkBlue,
kMagenta,
kLtMagenta,
kDkMagenta,
kYellow,
kLtYellow,
kDkYellow,
kOrange,
kLtOrange,
kDkOrange,
kGold,
kBlack50,
kBlack70,
kNumStandardColors,
kLtGray = kGray20,
kGray = kGray50,
kDkGray = kGray70
} |
| |
|
| template<class T > |
| int32 | _tstrlen (const T *wcs) |
| |
| int32 | tstrlen (const char *str) |
| |
| int32 | strlen8 (const char8 *str) |
| |
| int32 | strlen16 (const char16 *str) |
| |
| template<class T > |
| int32 | _tstrcmp (const T *src, const T *dst) |
| |
| int32 | tstrcmp (const char *src, const char *dst) |
| |
| int32 | strcmp8 (const char8 *src, const char8 *dst) |
| |
| int32 | strcmp16 (const char16 *src, const char16 *dst) |
| |
| template<typename T > |
| int32 | strcmpT (const T *first, const T *last) |
| |
| template<> |
| int32 | strcmpT< char8 > (const char8 *first, const char8 *last) |
| |
| template<> |
| int32 | strcmpT< char16 > (const char16 *first, const char16 *last) |
| |
| template<class T > |
| int32 | _tstrncmp (const T *first, const T *last, uint32 count) |
| |
| int32 | tstrncmp (const char *first, const char *last, uint32 count) |
| |
| int32 | strncmp8 (const char8 *first, const char8 *last, uint32 count) |
| |
| int32 | strncmp16 (const char16 *first, const char16 *last, uint32 count) |
| |
| template<typename T > |
| int32 | strncmpT (const T *first, const T *last, uint32 count) |
| |
| template<> |
| int32 | strncmpT< char8 > (const char8 *first, const char8 *last, uint32 count) |
| |
| template<> |
| int32 | strncmpT< char16 > (const char16 *first, const char16 *last, uint32 count) |
| |
| template<class T > |
| T * | _tstrcpy (T *dst, const T *src) |
| |
| char * | tstrcpy (char *dst, const char *src) |
| |
| char8 * | strcpy8 (char8 *dst, const char8 *src) |
| |
| char16 * | strcpy16 (char16 *dst, const char16 *src) |
| |
| template<class T > |
| T * | _tstrncpy (T *dest, const T *source, uint32 count) |
| |
| char * | tstrncpy (char *dest, const char *source, uint32 count) |
| |
| char8 * | strncpy8 (char8 *dest, const char8 *source, uint32 count) |
| |
| char16 * | strncpy16 (char16 *dest, const char16 *source, uint32 count) |
| |
| template<class T > |
| T * | _tstrcat (T *dst, const T *src) |
| |
| char * | tstrcat (char *dst, const char *src) |
| |
| char8 * | strcat8 (char8 *dst, const char8 *src) |
| |
| char16 * | strcat16 (char16 *dst, const char16 *src) |
| |
| void | str8ToStr16 (char16 *dst, const char8 *src, int32 n=-1) |
| |
| bool | FIDStringsEqual (FIDString id1, FIDString id2) |
| |
| bool | strEmpty (const char *str) |
| |
| bool | str8Empty (const char8 *str) |
| |
| bool | str16Empty (const char16 *str) |
| |
| template<typename T > |
| const TUID & | getTUID () |
| |
| template<class T > |
| const T & | Min (const T &a, const T &b) |
| |
| template<class T > |
| const T & | Max (const T &a, const T &b) |
| |
| template<class T > |
| T | Abs (const T &value) |
| |
| template<class T > |
| T | Sign (const T &value) |
| |
| template<class T > |
| T | Bound (T minval, T maxval, T x) |
| |
| template<class T > |
| void | Swap (T &t1, T &t2) |
| |
| template<class T > |
| bool | IsApproximateEqual (T t1, T t2, T epsilon) |
| |
| template<class T > |
| T | ToNormalized (const T &value, const int32 numSteps) |
| |
| template<class T > |
| int32 | FromNormalized (const T &norm, const int32 numSteps) |
| |
| bool | operator== (const FVariant &v1, const FVariant &v2) |
| |
| bool | operator!= (const FVariant &v1, const FVariant &v2) |
| |
| SMTG_CONSTEXPR14 char | VirtualKeyCodeToChar (uint8 vKey) |
| |
| SMTG_CONSTEXPR14 uint8 | CharToVirtualKeyCode (char character) |
| |
| template<class I > |
| IPtr< I > | owned (I *p) |
| | Assigning newly created object to an IPtr.
|
| |
| template<class I > |
| IPtr< I > | shared (I *p) |
| | Assigning shared object to an IPtr.
|
| |
| SMTG_CONSTEXPR ColorSpec | MakeColorSpec (ColorComponent r, ColorComponent g, ColorComponent b) |
| | Create color specifier with RGB values (alpha is opaque)
|
| |
| SMTG_CONSTEXPR ColorSpec | MakeColorSpec (ColorComponent r, ColorComponent g, ColorComponent b, ColorComponent a) |
| | Create color specifier with RGBA values.
|
| |
| SMTG_CONSTEXPR ColorComponent | GetBlue (ColorSpec cs) |
| |
| SMTG_CONSTEXPR ColorComponent | GetGreen (ColorSpec cs) |
| |
| SMTG_CONSTEXPR ColorComponent | GetRed (ColorSpec cs) |
| |
| SMTG_CONSTEXPR ColorComponent | GetAlpha (ColorSpec cs) |
| |
| void | SetBlue (ColorSpec &argb, ColorComponent b) |
| |
| void | SetGreen (ColorSpec &argb, ColorComponent g) |
| |
| void | SetRed (ColorSpec &argb, ColorComponent r) |
| |
| void | SetAlpha (ColorSpec &argb, ColorComponent a) |
| |
| double | NormalizeColorComponent (ColorComponent c) |
| | Normalized color components.
|
| |
| ColorComponent | DenormalizeColorComponent (double c) |
| |
| void | SetAlphaNorm (ColorSpec &argb, double a) |
| |
| double | GetAlphaNorm (ColorSpec cs) |
| |
| double | NormalizeAlpha (uint8 alpha) |
| |
| ColorComponent | DenormalizeAlpha (double alphaNorm) |
| |
| ColorSpec | StripAlpha (ColorSpec argb) |
| | }
|
| |
| ColorSpec SMTG_CONSTEXPR | BlendColor (ColorSpec color, double opacity) |
| |
| template<class TDstChar , class TSrcChar > |
| void | StringCopy (TDstChar *dst, int32 dstSize, const TSrcChar *src, int32 srcSize=-1) |
| | Copy strings of different character width.
|
| |
| template<class TSrcChar > |
| int32 | StringLength (const TSrcChar *src, int32 srcSize=-1) |
| | Find length of null-terminated string, i.e.
|
| |
This header provides classes for working with FUnknown.
An interface which shall support Steinbergs Module Architecture should inherit from U::Unknown and provide a typedef IID of type U::UID.
On OS X you can generate an U::UID and copy it to the clipboard with the following shell command:
uuidgen | { read id; echo -n "using IID = U::UID<0x${id:0:8}, 0x${id:9:4}${id:14:4}, 0x${id:19:4}${id:24:4}, 0x${id:28:8}>;" ; } | pbcopy
Example:
{
using IID = U::UID<0x01234567, 0x89012345, 0x67890123, 0x45678901>;
virtual void bar () = 0;
};
A class implementing the interface IFoo uses the U::Implements template to specify the interfaces it implements. All interfaces which the class should derive from need to be listed in the U::Directly template.
Example:
{
void bar () override {}
};
To check if a class can provide a specific interface use the U::cast function.
Example:
{
if (auto foo = U::cast<IFoo> (obj))
{
}
}
The U::Implements class supports a second template parameter U::Indirectly for specifying a list of interfaces which should be available via queryInterface but not inherited from. This is useful if an interface extends another interface.
Example:
struct IBar : public IFoo
{
using IID = U::UID<0x11223344, 0x55667788, 0x99001122, 0x33445566>;
virtual void baz () = 0;
};
struct BarImpl :
public U::Implements<U::Directly<IBar>, U::Indirectly<IFoo>>
{
void bar () override {}
void baz () override {}
};
In some cases a class shall be extended and an additional interface implemented. This is possible with the U::Extends template which is a generalization of the U::Implements template and allows specifying a base class from which should be inherited.
Example:
{
using IID = U::UID<0x99887766, 0x55443322, 0x11009988, 0x77665544>;
virtual bool equal (int a, int b) const = 0;
};
struct TestImpl :
public U::Extends<FooImpl, U::Directly<ITest>>
{
bool equal (int a, int b) const override { return a == b; }
};
To pass arbitrary arguments to the specified base class one can use the inherited Base typedef. All arguments passed to Base are automatically perfectly forwarded to the base class.
In the following example the value 42 is passed to the AlternativeFooImpl base class:
struct AlternativeFooImpl :
public U::Implements<U::Directly<IFoo>>
{
AlternativeFooImpl (int dummy = 0) : dummy {dummy} {}
void bar () override {}
int dummy;
};
struct AlternativeTestImpl :
public U::Extends<AlternativeFooImpl, U::Directly<ITest>>
{
AlternativeTestImpl () : Base {42} {}
bool equal (int a, int b) const override { return a == b; }
};
