UI library: added stubs allowing to compile library without use of additional UModel's code

Author: gildor2

UI/stl-stub/Core.h

@@ -0,0 +1,74 @@
+#ifndef __CORE_H__
+#define __CORE_H__
+
+//todo: should be defined before any include like windows.h etc - see BaseDialog.cpp
+#define _CRT_SECURE_NO_WARNINGS
+
+#include <stdio.h>
+#include <stdarg.h>
+
+
+#define HAS_UI 1
+
+#undef min
+#undef max
+
+#define min(a,b)				( ((a) < (b)) ? (a) : (b) )
+#define max(a,b)				( ((a) > (b)) ? (a) : (b) )
+#define bound(a,minval,maxval)	( ((a) > (minval)) ? ( ((a) < (maxval)) ? (a) : (maxval) ) : (minval) )
+
+#undef ARRAY_COUNT
+
+#define ARRAY_ARG(array)		array, sizeof(array)/sizeof(array[0])
+#define ARRAY_COUNT(array)		(sizeof(array)/sizeof(array[0]))
+
+#if _MSC_VER
+#	define FORCEINLINE			__forceinline
+#	define stricmp				_stricmp
+#	define strnicmp				_strnicmp
+#else
+#	error Unsupported compiler
+#endif
+
+#define guard(x)
+#define unguard
+#define unguardf(...)
+
+
+static void appError(const char* Format, ...)
+{
+	va_list	argptr;
+	va_start(argptr, Format);
+	char buffer[1024];
+	_vsnprintf_s(buffer, ARRAY_COUNT(buffer), Format, argptr);
+	va_end(argptr);
+
+	printf("%s", buffer);
+	exit(1);
+}
+
+static int appSprintf(char *dest, int size, const char *Format, ...)
+{
+	va_list	argptr;
+	va_start(argptr, Format);
+	int len = _vsnprintf_s(dest, size, size, Format, argptr);
+	va_end(argptr);
+	return len;
+}
+
+static void appStrncpyz(char *dst, const char *src, int count)
+{
+	int len = (int)strlen(src);
+	if (len >= count)
+		len = count-1;
+	strncpy(dst, src, len);
+	dst[len] = 0;
+}
+
+#ifndef assert
+#define assert(x)				if (!(x)) { appError("Assert: %s", #x); }
+#endif
+
+#define appNotify(...)
+
+#endif // __CORE_H__

UI/stl-stub/README.md

@@ -0,0 +1,4 @@
+This directory contains stub files which implements parts of UModel's core using STL. Should either copy these files
+into UI library's directory, or put path to this directory into compiler's include directories.
+
+Additional build requirements which are not here, but exists in UModel project: callback.hpp, Win32Types.h

UI/stl-stub/UnCore.h

@@ -0,0 +1,182 @@
+#ifndef __UN_CORE_H__
+#define __UN_CORE_H__
+
+#include <vector>
+#include <string>
+
+template<typename T>
+struct TArray
+{
+private:
+	std::vector<T>	items;
+
+public:
+	FORCEINLINE T* GetData()
+	{
+		return items.size() > 0 ? &items[0] : NULL;
+	}
+	FORCEINLINE const T* GetData() const
+	{
+		return items.size() > 0 ? &items[0] : NULL;
+	}
+	FORCEINLINE T& operator[](int index)
+	{
+		return items[index];
+	}
+	FORCEINLINE const T& operator[](int index) const
+	{
+		return items[index];
+	}
+	FORCEINLINE int Num() const
+	{
+		return (int)items.size();
+	}
+	inline void Empty(int Count = 0)
+	{
+		items.resize(0);
+		if (Count)
+		{
+			items.reserve(Count);
+		}
+	}
+	FORCEINLINE void Reset(int Count = 0)
+	{
+		Empty(Count);
+	}
+	FORCEINLINE int Add(const T& item)
+	{
+		size_t OldCount = items.size();
+		items.push_back(item);
+		return (int)OldCount;
+	}
+	inline int AddZeroed(int Count = 1)
+	{
+		size_t OldCount = items.size();
+		items.resize(OldCount + Count);
+		return (int)OldCount;
+	}
+	FORCEINLINE int AddUninitialized(int Count = 1)
+	{
+		return AddZeroed(Count);
+	}
+	FORCEINLINE void ResizeTo(int count)
+	{
+		items.resize(count);
+	}
+	void RemoveAt(int index, int count = 1)
+	{
+		items.erase(items.begin() + index, items.begin() + index + count);
+	}
+	FORCEINLINE void RemoveAtSwap(int index, int count = 1)
+	{
+		RemoveAt(index, count);
+	}
+	int FindItem(const T& item, int startIndex = 0) const
+	{
+		for (int i = startIndex; i < items.size(); i++)
+		{
+			if (items[i] == item)
+			{
+				return i;
+			}
+		}
+		return -1;
+	}
+	FORCEINLINE void Sort(int (*cmpFunc)(const T*, const T*))
+	{
+		if (items.size() > 0)
+		{
+			qsort(&items[0], items.size(), sizeof(T), (int (*)(const void*, const void*)) cmpFunc);
+		}
+	}
+};
+
+template<typename T>
+inline void* operator new(size_t size, TArray<T> &Array)
+{
+	assert(size == sizeof(T)); // allocating wrong object? can't disallow allocating of "int" inside "TArray<FString>" at compile time ...
+	int index = Array.AddUninitialized(1);
+	return Array.GetData() + index;
+}
+
+// Just shut up compiler
+template<typename T>
+inline void operator delete(void* ptr, TArray<T> &Array)
+{
+	assert(0);
+}
+
+struct FString
+{
+private:
+	std::string str;
+
+public:
+	FString()
+	{}
+	FString(const char* src)
+	: str(src)
+	{}
+	FString& operator=(const char* src)
+	{
+		str = src;
+		return *this;
+	}
+	FString& operator+=(const char* text)
+	{
+		str += text;
+		return *this;
+	}
+	FORCEINLINE FString& operator+=(const FString& Str)
+	{
+		str += *Str;
+		return *this;
+	}
+	FORCEINLINE FString& AppendChar(char ch)
+	{
+		str += ch;
+		return *this;
+	}
+	FORCEINLINE const char* operator*() const
+	{
+		return str.c_str();
+	}
+	FORCEINLINE bool IsEmpty() const
+	{
+		return str.length() == 0;
+	}
+	FORCEINLINE char& operator[](int index)
+	{
+		return str[index];
+	}
+	FORCEINLINE const char& operator[](int index) const
+	{
+		return str[index];
+	}
+	FORCEINLINE int Len() const
+	{
+		return (int)str.length();
+	}
+};
+
+// No TStaticArray FStaticString
+
+template<typename T, int N>
+struct TStaticArray : public TArray<T>
+{
+};
+
+template<int N>
+struct FStaticString : public FString
+{
+	FORCEINLINE FStaticString& operator=(const char* src)
+	{
+		return (FStaticString&) FString::operator=(src);
+	}
+	FORCEINLINE FStaticString& operator=(const FString& src)
+	{
+		return (FStaticString&) FString::operator=(src);
+	}
+};
+
+#endif // __UN_CORE_H__